Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
89%
10048/11231
24%
1215/4886
11,672
SparqlParser$DFA4
95%
22/23
N/A
N/A
11,672
SparqlParser$add_return
0%
0/2
N/A
N/A
11,672
SparqlParser$additiveExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$additiveOperator_return
100%
4/4
N/A
N/A
11,672
SparqlParser$aggregate_return
100%
4/4
N/A
N/A
11,672
SparqlParser$anon_return
100%
4/4
N/A
N/A
11,672
SparqlParser$argList_return
100%
2/2
N/A
N/A
11,672
SparqlParser$askQuery_return
100%
2/2
N/A
N/A
11,672
SparqlParser$baseDecl_return
100%
2/2
N/A
N/A
11,672
SparqlParser$bind_return
100%
2/2
N/A
N/A
11,672
SparqlParser$bindingValueList_return
100%
2/2
N/A
N/A
11,672
SparqlParser$bindingValue_return
100%
2/2
N/A
N/A
11,672
SparqlParser$bindingsClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$blankNode_return
100%
4/4
N/A
N/A
11,672
SparqlParser$booleanLiteral_return
100%
4/4
N/A
N/A
11,672
SparqlParser$brackettedExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$builtInCall_return
100%
4/4
N/A
N/A
11,672
SparqlParser$clear_return
100%
2/2
N/A
N/A
11,672
SparqlParser$conditionalAndExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$conditionalOrExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$constraint_return
100%
2/2
N/A
N/A
11,672
SparqlParser$constructQuery_return
100%
2/2
N/A
N/A
11,672
SparqlParser$constructTemplate_return
100%
2/2
N/A
N/A
11,672
SparqlParser$constructTriples_return
100%
2/2
N/A
N/A
11,672
SparqlParser$copy_return
0%
0/2
N/A
N/A
11,672
SparqlParser$create_return
0%
0/2
N/A
N/A
11,672
SparqlParser$datasetClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$deleteClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$deleteData_return
100%
2/2
N/A
N/A
11,672
SparqlParser$deleteWhere_return
100%
2/2
N/A
N/A
11,672
SparqlParser$delete_return
100%
2/2
N/A
N/A
11,672
SparqlParser$describeQuery_return
100%
2/2
N/A
N/A
11,672
SparqlParser$drop_return
100%
2/2
N/A
N/A
11,672
SparqlParser$existsFunction_return
100%
4/4
N/A
N/A
11,672
SparqlParser$expressionList_return
100%
2/2
N/A
N/A
11,672
SparqlParser$expression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$filter_return
100%
2/2
N/A
N/A
11,672
SparqlParser$functionCall_return
100%
2/2
N/A
N/A
11,672
SparqlParser$graphGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$graphNode_return
100%
4/4
N/A
N/A
11,672
SparqlParser$graphOrDefault_return
0%
0/2
N/A
N/A
11,672
SparqlParser$graphPatternNotTriples_return
100%
2/2
N/A
N/A
11,672
SparqlParser$graphRefAll_return
100%
2/2
N/A
N/A
11,672
SparqlParser$graphRef_return
100%
2/2
N/A
N/A
11,672
SparqlParser$graphTerm_return
100%
4/4
N/A
N/A
11,672
SparqlParser$groupClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$groupCondition_return
100%
2/2
N/A
N/A
11,672
SparqlParser$groupGraphPatternSubDetail_return
100%
2/2
N/A
N/A
11,672
SparqlParser$groupGraphPatternSub_return
100%
2/2
N/A
N/A
11,672
SparqlParser$groupGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$groupOrUnionGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$havingClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$insertClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$insert_return
100%
2/2
N/A
N/A
11,672
SparqlParser$iriRefOrFunction_return
100%
4/4
N/A
N/A
11,672
SparqlParser$iriRef_return
100%
4/4
N/A
N/A
11,672
SparqlParser$limitClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$limitOffsetClauses_return
100%
2/2
N/A
N/A
11,672
SparqlParser$load_return
0%
0/2
N/A
N/A
11,672
SparqlParser$minusGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$modify_return
100%
2/2
N/A
N/A
11,672
SparqlParser$move_return
0%
0/2
N/A
N/A
11,672
SparqlParser$multiplicativeExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$multiplicativeOperator_return
100%
4/4
N/A
N/A
11,672
SparqlParser$nil_return
100%
4/4
N/A
N/A
11,672
SparqlParser$notExistsFunction_return
100%
4/4
N/A
N/A
11,672
SparqlParser$numericExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$numericLiteralNegative_return
100%
4/4
N/A
N/A
11,672
SparqlParser$numericLiteralPositive_return
100%
4/4
N/A
N/A
11,672
SparqlParser$numericLiteralUnsigned_return
100%
4/4
N/A
N/A
11,672
SparqlParser$numericLiteral_return
100%
4/4
N/A
N/A
11,672
SparqlParser$objectList_return
100%
2/2
N/A
N/A
11,672
SparqlParser$offsetClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$optionalGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$orderClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$orderCondition_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathEltOrInverse_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathElt_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathMod_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathNegatedPropertySet_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathOneInPropertySet_return
100%
4/4
N/A
N/A
11,672
SparqlParser$pathPrimary_return
100%
2/2
N/A
N/A
11,672
SparqlParser$pathSequence_return
100%
2/2
N/A
N/A
11,672
SparqlParser$path_return
100%
2/2
N/A
N/A
11,672
SparqlParser$prefixDecl_return
100%
2/2
N/A
N/A
11,672
SparqlParser$prefixedName_return
100%
4/4
N/A
N/A
11,672
SparqlParser$primaryExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$prologue_return
100%
2/2
N/A
N/A
11,672
SparqlParser$propertyListNotEmptyDetails_return
100%
2/2
N/A
N/A
11,672
SparqlParser$propertyListNotEmptyPath_return
100%
2/2
N/A
N/A
11,672
SparqlParser$propertyListNotEmpty_return
100%
2/2
N/A
N/A
11,672
SparqlParser$quadPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$quadsNotTriples_return
100%
2/2
N/A
N/A
11,672
SparqlParser$quads_return
100%
2/2
N/A
N/A
11,672
SparqlParser$query_return
100%
2/2
N/A
N/A
11,672
SparqlParser$rdfLiteral_return
100%
4/4
N/A
N/A
11,672
SparqlParser$regexExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$relationalExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$selectClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$selectQuery_return
100%
2/2
N/A
N/A
11,672
SparqlParser$selectVariables_return
100%
2/2
N/A
N/A
11,672
SparqlParser$serviceGraphPattern_return
100%
2/2
N/A
N/A
11,672
SparqlParser$solutionModifier_return
100%
2/2
N/A
N/A
11,672
SparqlParser$string_return
100%
4/4
N/A
N/A
11,672
SparqlParser$subSelect_return
100%
2/2
N/A
N/A
11,672
SparqlParser$subStringExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$triplesBlock_return
100%
2/2
N/A
N/A
11,672
SparqlParser$triplesNode_return
100%
4/4
N/A
N/A
11,672
SparqlParser$triplesSameSubjectPath_return
100%
2/2
N/A
N/A
11,672
SparqlParser$triplesSameSubject_return
100%
2/2
N/A
N/A
11,672
SparqlParser$triplesTemplate_return
100%
2/2
N/A
N/A
11,672
SparqlParser$unaryExpression_return
100%
4/4
N/A
N/A
11,672
SparqlParser$update_return
100%
2/2
N/A
N/A
11,672
SparqlParser$usingClause_return
100%
2/2
N/A
N/A
11,672
SparqlParser$valueLogical_return
100%
4/4
N/A
N/A
11,672
SparqlParser$varOrIRIref_return
100%
4/4
N/A
N/A
11,672
SparqlParser$varOrTerm_return
100%
4/4
N/A
N/A
11,672
SparqlParser$var_return
100%
4/4
N/A
N/A
11,672
SparqlParser$verbPath_return
100%
2/2
N/A
N/A
11,672
SparqlParser$verbSimpleOrPath_return
100%
2/2
N/A
N/A
11,672
SparqlParser$verbSimple_return
100%
2/2
N/A
N/A
11,672
SparqlParser$verb_return
0%
0/2
N/A
N/A
11,672
SparqlParser$whereClause_return
100%
2/2
N/A
N/A
11,672
 
 1   
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2011-12-06 23:49:47
 2   
 
 3   
     package com.googlecode.sparkleg;
 4   
 
 5   
 
 6   
 import org.antlr.runtime.*;
 7   
 import java.util.Stack;
 8   
 import java.util.List;
 9   
 import java.util.ArrayList;
 10   
 
 11   
 import org.antlr.runtime.tree.*;
 12   
 
 13   
 
 14   
 /**
 15   
  * @author Simone Tripodi   (simone.tripodi)
 16   
  * @author Michele Mostarda (michele.mostarda)
 17   
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18   
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19   
  */
 20   
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21   
 public class SparqlParser extends Parser {
 22  2 
     public static final String[] tokenNames = new String[] {
 23   
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "CLOSE_BRACE", "CLOSE_CURLY_BRACE", "CLOSE_SQUARE_BRACKET", "COALESCE", "COLLECTION", "COMMA", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPEN_BRACE", "OPEN_CURLY_BRACE", "OPEN_SQUARE_BRACKET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PIPE", "PLUS", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "REDUCED", "REFERENCE", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEMICOLON", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR"
 24   
     };
 25   
 
 26   
     public static final int EOF=-1;
 27   
     public static final int A=4;
 28   
     public static final int ABS=5;
 29   
     public static final int ADD=6;
 30   
     public static final int ALL=7;
 31   
     public static final int AND=8;
 32   
     public static final int ANY=9;
 33   
     public static final int ARG_LIST=10;
 34   
     public static final int AS=11;
 35   
     public static final int ASC=12;
 36   
     public static final int ASK=13;
 37   
     public static final int ASTERISK=14;
 38   
     public static final int AVG=15;
 39   
     public static final int BASE=16;
 40   
     public static final int BIND=17;
 41   
     public static final int BINDINGS=18;
 42   
     public static final int BINDING_VALUE=19;
 43   
     public static final int BLANK_NODE=20;
 44   
     public static final int BLANK_NODE_LABEL=21;
 45   
     public static final int BNODE=22;
 46   
     public static final int BOUND=23;
 47   
     public static final int BRACKETTED_EXPRESSION=24;
 48   
     public static final int BY=25;
 49   
     public static final int CEIL=26;
 50   
     public static final int CLEAR=27;
 51   
     public static final int CLOSE_BRACE=28;
 52   
     public static final int CLOSE_CURLY_BRACE=29;
 53   
     public static final int CLOSE_SQUARE_BRACKET=30;
 54   
     public static final int COALESCE=31;
 55   
     public static final int COLLECTION=32;
 56   
     public static final int COMMA=33;
 57   
     public static final int COMMENT=34;
 58   
     public static final int CONCAT=35;
 59   
     public static final int CONSTRUCT=36;
 60   
     public static final int CONSTRUCT_TRIPLES=37;
 61   
     public static final int CONTAINS=38;
 62   
     public static final int COPY=39;
 63   
     public static final int COUNT=40;
 64   
     public static final int CREATE=41;
 65   
     public static final int DATA=42;
 66   
     public static final int DATATYPE=43;
 67   
     public static final int DAY=44;
 68   
     public static final int DECIMAL=45;
 69   
     public static final int DECIMAL_NEGATIVE=46;
 70   
     public static final int DECIMAL_POSITIVE=47;
 71   
     public static final int DEFAULT=48;
 72   
     public static final int DELETE=49;
 73   
     public static final int DESC=50;
 74   
     public static final int DESCRIBE=51;
 75   
     public static final int DIGIT=52;
 76   
     public static final int DISTINCT=53;
 77   
     public static final int DIVIDE=54;
 78   
     public static final int DOT=55;
 79   
     public static final int DOUBLE=56;
 80   
     public static final int DOUBLE_NEGATIVE=57;
 81   
     public static final int DOUBLE_POSITIVE=58;
 82   
     public static final int DROP=59;
 83   
     public static final int ECHAR=60;
 84   
     public static final int ENCODE_FOR_URI=61;
 85   
     public static final int EOL=62;
 86   
     public static final int EQUAL=63;
 87   
     public static final int EXISTS=64;
 88   
     public static final int EXPONENT=65;
 89   
     public static final int EXPRESSION_LIST=66;
 90   
     public static final int FALSE=67;
 91   
     public static final int FILTER=68;
 92   
     public static final int FLOOR=69;
 93   
     public static final int FROM=70;
 94   
     public static final int FUNCTION=71;
 95   
     public static final int GRAPH=72;
 96   
     public static final int GREATER=73;
 97   
     public static final int GREATER_EQUAL=74;
 98   
     public static final int GROUP=75;
 99   
     public static final int GROUP_BY=76;
 100   
     public static final int GROUP_CONCAT=77;
 101   
     public static final int GROUP_CONDITION=78;
 102   
     public static final int GROUP_GRAPH_PATTERN=79;
 103   
     public static final int HAVING=80;
 104   
     public static final int HOURS=81;
 105   
     public static final int IF=82;
 106   
     public static final int IN=83;
 107   
     public static final int INSERT=84;
 108   
     public static final int INTEGER=85;
 109   
     public static final int INTEGER_NEGATIVE=86;
 110   
     public static final int INTEGER_POSITIVE=87;
 111   
     public static final int INTO=88;
 112   
     public static final int INVERSE=89;
 113   
     public static final int IRI=90;
 114   
     public static final int IRI_REF=91;
 115   
     public static final int IRI_REF_CHARACTERS=92;
 116   
     public static final int ISBLANK=93;
 117   
     public static final int ISIRI=94;
 118   
     public static final int ISLITERAL=95;
 119   
     public static final int ISNUMERIC=96;
 120   
     public static final int ISURI=97;
 121   
     public static final int LANG=98;
 122   
     public static final int LANGMATCHES=99;
 123   
     public static final int LANGTAG=100;
 124   
     public static final int LCASE=101;
 125   
     public static final int LESS=102;
 126   
     public static final int LESS_EQUAL=103;
 127   
     public static final int LIMIT=104;
 128   
     public static final int LOAD=105;
 129   
     public static final int MAX=106;
 130   
     public static final int MD5=107;
 131   
     public static final int MIN=108;
 132   
     public static final int MINUS=109;
 133   
     public static final int MINUS_KEYWORD=110;
 134   
     public static final int MINUTES=111;
 135   
     public static final int MODIFY=112;
 136   
     public static final int MONTH=113;
 137   
     public static final int MOVE=114;
 138   
     public static final int NAMED=115;
 139   
     public static final int NEGATION=116;
 140   
     public static final int NOT=117;
 141   
     public static final int NOT_EQUAL=118;
 142   
     public static final int NOT_EXISTS=119;
 143   
     public static final int NOW=120;
 144   
     public static final int OBJECT=121;
 145   
     public static final int OFFSET=122;
 146   
     public static final int OPEN_BRACE=123;
 147   
     public static final int OPEN_CURLY_BRACE=124;
 148   
     public static final int OPEN_SQUARE_BRACKET=125;
 149   
     public static final int OPTIONAL=126;
 150   
     public static final int OR=127;
 151   
     public static final int ORDER=128;
 152   
     public static final int ORDER_BY=129;
 153   
     public static final int ORDER_CONDITION=130;
 154   
     public static final int PATH=131;
 155   
     public static final int PATH_NEGATED=132;
 156   
     public static final int PATH_PRIMARY=133;
 157   
     public static final int PATH_SEQUENCE=134;
 158   
     public static final int PIPE=135;
 159   
     public static final int PLUS=136;
 160   
     public static final int PNAME_LN=137;
 161   
     public static final int PNAME_NS=138;
 162   
     public static final int PN_CHARS=139;
 163   
     public static final int PN_CHARS_BASE=140;
 164   
     public static final int PN_CHARS_U=141;
 165   
     public static final int PN_LOCAL=142;
 166   
     public static final int PN_PREFIX=143;
 167   
     public static final int PREDICATE=144;
 168   
     public static final int PREFIX=145;
 169   
     public static final int PROLOGUE=146;
 170   
     public static final int QUERY=147;
 171   
     public static final int QUESTION_MARK=148;
 172   
     public static final int RAND=149;
 173   
     public static final int REDUCED=150;
 174   
     public static final int REFERENCE=151;
 175   
     public static final int REGEX=152;
 176   
     public static final int REPLACE=153;
 177   
     public static final int ROUND=154;
 178   
     public static final int SAMETERM=155;
 179   
     public static final int SAMPLE=156;
 180   
     public static final int SECONDS=157;
 181   
     public static final int SELECT=158;
 182   
     public static final int SELECT_CLAUSE=159;
 183   
     public static final int SEMICOLON=160;
 184   
     public static final int SEPARATOR=161;
 185   
     public static final int SERVICE=162;
 186   
     public static final int SHA1=163;
 187   
     public static final int SHA224=164;
 188   
     public static final int SHA256=165;
 189   
     public static final int SHA384=166;
 190   
     public static final int SHA512=167;
 191   
     public static final int SIGN=168;
 192   
     public static final int SILENT=169;
 193   
     public static final int STR=170;
 194   
     public static final int STRAFTER=171;
 195   
     public static final int STRBEFORE=172;
 196   
     public static final int STRDT=173;
 197   
     public static final int STRENDS=174;
 198   
     public static final int STRING_LITERAL1=175;
 199   
     public static final int STRING_LITERAL2=176;
 200   
     public static final int STRING_LITERAL_LONG1=177;
 201   
     public static final int STRING_LITERAL_LONG2=178;
 202   
     public static final int STRLANG=179;
 203   
     public static final int STRLEN=180;
 204   
     public static final int STRSTARTS=181;
 205   
     public static final int SUBJECT=182;
 206   
     public static final int SUBSELECT=183;
 207   
     public static final int SUBSTR=184;
 208   
     public static final int SUM=185;
 209   
     public static final int TIMEZONE=186;
 210   
     public static final int TO=187;
 211   
     public static final int TRIPLES_BLOCK=188;
 212   
     public static final int TRIPLES_NODE=189;
 213   
     public static final int TRIPLES_SAME_SUBJECT=190;
 214   
     public static final int TRIPLES_TEMPLATE=191;
 215   
     public static final int TRUE=192;
 216   
     public static final int TZ=193;
 217   
     public static final int UCASE=194;
 218   
     public static final int UNARY=195;
 219   
     public static final int UNDEF=196;
 220   
     public static final int UNION=197;
 221   
     public static final int UPDATE=198;
 222   
     public static final int URI=199;
 223   
     public static final int USING=200;
 224   
     public static final int VAR=201;
 225   
     public static final int VAR1=202;
 226   
     public static final int VAR2=203;
 227   
     public static final int VARNAME=204;
 228   
     public static final int WHERE=205;
 229   
     public static final int WHERE_CLAUSE=206;
 230   
     public static final int WITH=207;
 231   
     public static final int WS=208;
 232   
     public static final int YEAR=209;
 233   
 
 234   
     // delegates
 235   
     public Parser[] getDelegates() {
 236  0 
         return new Parser[] {};
 237   
     }
 238   
 
 239   
     // delegators
 240   
 
 241   
 
 242   
     public SparqlParser(TokenStream input) {
 243  1958 
         this(input, new RecognizerSharedState());
 244  1958 
     }
 245   
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 246  1958 
         super(input, state);
 247  1958 
     }
 248   
 
 249  1958 
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 250   
 
 251   
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 252  0 
     this.adaptor = adaptor;
 253  0 
 }
 254   
 public TreeAdaptor getTreeAdaptor() {
 255  0 
     return adaptor;
 256   
 }
 257  106 
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 258  0 
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 259   
 
 260   
 
 261  1958 
     public static class query_return extends ParserRuleReturnScope {
 262   
         Object tree;
 263  1958 
         public Object getTree() { return tree; }
 264   
     };
 265   
 
 266   
 
 267   
     // $ANTLR start "query"
 268   
     // com\\googlecode\\sparkleg\\Sparql.g:76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 269   
     public final SparqlParser.query_return query() throws RecognitionException {
 270  1958 
         SparqlParser.query_return retval = new SparqlParser.query_return();
 271  1958 
         retval.start = input.LT(1);
 272   
 
 273   
 
 274  1958 
         Object root_0 = null;
 275   
 
 276  1958 
         Token EOF7=null;
 277  1958 
         Token SEMICOLON9=null;
 278  1958 
         Token EOF11=null;
 279  1958 
         SparqlParser.prologue_return prologue1 =null;
 280   
 
 281  1958 
         SparqlParser.selectQuery_return selectQuery2 =null;
 282   
 
 283  1958 
         SparqlParser.constructQuery_return constructQuery3 =null;
 284   
 
 285  1958 
         SparqlParser.describeQuery_return describeQuery4 =null;
 286   
 
 287  1958 
         SparqlParser.askQuery_return askQuery5 =null;
 288   
 
 289  1958 
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 290   
 
 291  1958 
         SparqlParser.update_return update8 =null;
 292   
 
 293  1958 
         SparqlParser.update_return update10 =null;
 294   
 
 295   
 
 296  1958 
         Object EOF7_tree=null;
 297  1958 
         Object SEMICOLON9_tree=null;
 298  1958 
         Object EOF11_tree=null;
 299  1958 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 300  1958 
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 301  1958 
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 302  1958 
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 303  1958 
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 304  1958 
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 305  1958 
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 306  1958 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 307  1958 
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 308   
         try {
 309   
             // com\\googlecode\\sparkleg\\Sparql.g:77:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 310  1958 
             int alt4=2;
 311  1958 
             alt4 = dfa4.predict(input);
 312  1958 
             switch (alt4) {
 313   
                 case 1 :
 314   
                     // com\\googlecode\\sparkleg\\Sparql.g:77:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 315   
                     {
 316  1834 
                     pushFollow(FOLLOW_prologue_in_query155);
 317  1834 
                     prologue1=prologue();
 318   
 
 319  1834 
                     state._fsp--;
 320   
 
 321  1834 
                     stream_prologue.add(prologue1.getTree());
 322   
 
 323   
                     // com\\googlecode\\sparkleg\\Sparql.g:77:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 324  1834 
                     int alt1=4;
 325  1834 
                     switch ( input.LA(1) ) {
 326   
                     case SELECT:
 327   
                         {
 328  1614 
                         alt1=1;
 329   
                         }
 330  1614 
                         break;
 331   
                     case CONSTRUCT:
 332   
                         {
 333  72 
                         alt1=2;
 334   
                         }
 335  72 
                         break;
 336   
                     case DESCRIBE:
 337   
                         {
 338  28 
                         alt1=3;
 339   
                         }
 340  28 
                         break;
 341   
                     case ASK:
 342   
                         {
 343  120 
                         alt1=4;
 344   
                         }
 345  120 
                         break;
 346   
                     default:
 347  0 
                         NoViableAltException nvae =
 348   
                             new NoViableAltException("", 1, 0, input);
 349   
 
 350  0 
                         throw nvae;
 351   
 
 352   
                     }
 353   
 
 354  1834 
                     switch (alt1) {
 355   
                         case 1 :
 356   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:17: selectQuery
 357   
                             {
 358  1614 
                             pushFollow(FOLLOW_selectQuery_in_query158);
 359  1614 
                             selectQuery2=selectQuery();
 360   
 
 361  1614 
                             state._fsp--;
 362   
 
 363  1614 
                             stream_selectQuery.add(selectQuery2.getTree());
 364   
 
 365   
                             }
 366  1614 
                             break;
 367   
                         case 2 :
 368   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:31: constructQuery
 369   
                             {
 370  72 
                             pushFollow(FOLLOW_constructQuery_in_query162);
 371  72 
                             constructQuery3=constructQuery();
 372   
 
 373  72 
                             state._fsp--;
 374   
 
 375  72 
                             stream_constructQuery.add(constructQuery3.getTree());
 376   
 
 377   
                             }
 378  72 
                             break;
 379   
                         case 3 :
 380   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:48: describeQuery
 381   
                             {
 382  28 
                             pushFollow(FOLLOW_describeQuery_in_query166);
 383  28 
                             describeQuery4=describeQuery();
 384   
 
 385  28 
                             state._fsp--;
 386   
 
 387  28 
                             stream_describeQuery.add(describeQuery4.getTree());
 388   
 
 389   
                             }
 390  28 
                             break;
 391   
                         case 4 :
 392   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:64: askQuery
 393   
                             {
 394  120 
                             pushFollow(FOLLOW_askQuery_in_query170);
 395  120 
                             askQuery5=askQuery();
 396   
 
 397  120 
                             state._fsp--;
 398   
 
 399  120 
                             stream_askQuery.add(askQuery5.getTree());
 400   
 
 401   
                             }
 402   
                             break;
 403   
 
 404   
                     }
 405   
 
 406   
 
 407  1834 
                     pushFollow(FOLLOW_bindingsClause_in_query173);
 408  1834 
                     bindingsClause6=bindingsClause();
 409   
 
 410  1834 
                     state._fsp--;
 411   
 
 412  1834 
                     stream_bindingsClause.add(bindingsClause6.getTree());
 413   
 
 414  1834 
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query175);
 415  1834 
                     stream_EOF.add(EOF7);
 416   
 
 417   
 
 418   
                     // AST REWRITE
 419   
                     // elements: selectQuery, bindingsClause, describeQuery, prologue, constructQuery, askQuery
 420   
                     // token labels:
 421   
                     // rule labels: retval
 422   
                     // token list labels:
 423   
                     // rule list labels:
 424   
                     // wildcard labels:
 425  1834 
                     retval.tree = root_0;
 426  1834 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 427   
 
 428  1834 
                     root_0 = (Object)adaptor.nil();
 429   
                     // 77:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 430   
                     {
 431   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 432   
                         {
 433  1834 
                         Object root_1 = (Object)adaptor.nil();
 434  1834 
                         root_1 = (Object)adaptor.becomeRoot(
 435   
                         (Object)adaptor.create(QUERY, "QUERY")
 436   
                         , root_1);
 437   
 
 438  1834 
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 439   
 
 440   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:113: ( selectQuery )*
 441  3448 
                         while ( stream_selectQuery.hasNext() ) {
 442  1614 
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 443   
 
 444   
                         }
 445  1834 
                         stream_selectQuery.reset();
 446   
 
 447   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:126: ( constructQuery )*
 448  1906 
                         while ( stream_constructQuery.hasNext() ) {
 449  72 
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 450   
 
 451   
                         }
 452  1834 
                         stream_constructQuery.reset();
 453   
 
 454   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:142: ( describeQuery )*
 455  1862 
                         while ( stream_describeQuery.hasNext() ) {
 456  28 
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 457   
 
 458   
                         }
 459  1834 
                         stream_describeQuery.reset();
 460   
 
 461   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:157: ( askQuery )*
 462  1954 
                         while ( stream_askQuery.hasNext() ) {
 463  120 
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 464   
 
 465   
                         }
 466  1834 
                         stream_askQuery.reset();
 467   
 
 468  1834 
                         adaptor.addChild(root_0, root_1);
 469   
                         }
 470   
 
 471   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:168: ( bindingsClause )*
 472  1860 
                         while ( stream_bindingsClause.hasNext() ) {
 473  26 
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 474   
 
 475   
                         }
 476  1834 
                         stream_bindingsClause.reset();
 477   
 
 478   
                     }
 479   
 
 480   
 
 481  1834 
                     retval.tree = root_0;
 482   
 
 483   
                     }
 484  1834 
                     break;
 485   
                 case 2 :
 486   
                     // com\\googlecode\\sparkleg\\Sparql.g:78:7: update ( SEMICOLON ( update )? )* EOF
 487   
                     {
 488  124 
                     pushFollow(FOLLOW_update_in_query206);
 489  124 
                     update8=update();
 490   
 
 491  124 
                     state._fsp--;
 492   
 
 493  124 
                     stream_update.add(update8.getTree());
 494   
 
 495   
                     // com\\googlecode\\sparkleg\\Sparql.g:78:14: ( SEMICOLON ( update )? )*
 496   
                     loop3:
 497   
                     do {
 498  128 
                         int alt3=2;
 499  128 
                         switch ( input.LA(1) ) {
 500   
                         case SEMICOLON:
 501   
                             {
 502  4 
                             alt3=1;
 503   
                             }
 504   
                             break;
 505   
 
 506   
                         }
 507   
 
 508  128 
                         switch (alt3) {
 509   
                             case 1 :
 510   
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:15: SEMICOLON ( update )?
 511   
                                 {
 512  4 
                                 SEMICOLON9=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_query209);
 513  4 
                                 stream_SEMICOLON.add(SEMICOLON9);
 514   
 
 515   
 
 516   
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:25: ( update )?
 517  4 
                                 int alt2=2;
 518  4 
                                 switch ( input.LA(1) ) {
 519   
                                     case ADD:
 520   
                                     case ASK:
 521   
                                     case BASE:
 522   
                                     case CLEAR:
 523   
                                     case CONSTRUCT:
 524   
                                     case COPY:
 525   
                                     case CREATE:
 526   
                                     case DELETE:
 527   
                                     case DESCRIBE:
 528   
                                     case DROP:
 529   
                                     case INSERT:
 530   
                                     case LOAD:
 531   
                                     case MOVE:
 532   
                                     case PREFIX:
 533   
                                     case SELECT:
 534   
                                     case WITH:
 535   
                                         {
 536  4 
                                         alt2=1;
 537   
                                         }
 538   
                                         break;
 539   
                                 }
 540   
 
 541  4 
                                 switch (alt2) {
 542   
                                     case 1 :
 543   
                                         // com\\googlecode\\sparkleg\\Sparql.g:78:25: update
 544   
                                         {
 545  4 
                                         pushFollow(FOLLOW_update_in_query211);
 546  4 
                                         update10=update();
 547   
 
 548  4 
                                         state._fsp--;
 549   
 
 550  4 
                                         stream_update.add(update10.getTree());
 551   
 
 552   
                                         }
 553   
                                         break;
 554   
 
 555   
                                 }
 556   
 
 557   
 
 558   
                                 }
 559  4 
                                 break;
 560   
 
 561   
                             default :
 562  124 
                                 break loop3;
 563   
                         }
 564  4 
                     } while (true);
 565   
 
 566   
 
 567  124 
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query216);
 568  124 
                     stream_EOF.add(EOF11);
 569   
 
 570   
 
 571   
                     // AST REWRITE
 572   
                     // elements: update
 573   
                     // token labels:
 574   
                     // rule labels: retval
 575   
                     // token list labels:
 576   
                     // rule list labels:
 577   
                     // wildcard labels:
 578  124 
                     retval.tree = root_0;
 579  124 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 580   
 
 581  124 
                     root_0 = (Object)adaptor.nil();
 582   
                     // 78:39: -> ^( UPDATE ( update )+ )
 583   
                     {
 584   
                         // com\\googlecode\\sparkleg\\Sparql.g:78:42: ^( UPDATE ( update )+ )
 585   
                         {
 586  124 
                         Object root_1 = (Object)adaptor.nil();
 587  124 
                         root_1 = (Object)adaptor.becomeRoot(
 588   
                         (Object)adaptor.create(UPDATE, "UPDATE")
 589   
                         , root_1);
 590   
 
 591  124 
                         if ( !(stream_update.hasNext()) ) {
 592  0 
                             throw new RewriteEarlyExitException();
 593   
                         }
 594  252 
                         while ( stream_update.hasNext() ) {
 595  128 
                             adaptor.addChild(root_1, stream_update.nextTree());
 596   
 
 597   
                         }
 598  124 
                         stream_update.reset();
 599   
 
 600  124 
                         adaptor.addChild(root_0, root_1);
 601   
                         }
 602   
 
 603   
                     }
 604   
 
 605   
 
 606  124 
                     retval.tree = root_0;
 607   
 
 608   
                     }
 609   
                     break;
 610   
 
 611   
             }
 612  1958 
             retval.stop = input.LT(-1);
 613   
 
 614   
 
 615  1958 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 616  1958 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 617   
 
 618   
         }
 619  0 
         catch (RecognitionException re) {
 620  0 
             reportError(re);
 621  0 
             recover(input,re);
 622  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 623   
 
 624   
         }
 625   
 
 626  0 
         finally {
 627   
                 // do for sure before leaving
 628  1958 
         }
 629  1958 
         return retval;
 630   
     }
 631   
     // $ANTLR end "query"
 632   
 
 633   
 
 634  1962 
     public static class prologue_return extends ParserRuleReturnScope {
 635   
         Object tree;
 636  1962 
         public Object getTree() { return tree; }
 637   
     };
 638   
 
 639   
 
 640   
     // $ANTLR start "prologue"
 641   
     // com\\googlecode\\sparkleg\\Sparql.g:81:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 642   
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 643  1962 
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 644  1962 
         retval.start = input.LT(1);
 645   
 
 646   
 
 647  1962 
         Object root_0 = null;
 648   
 
 649  1962 
         SparqlParser.baseDecl_return baseDecl12 =null;
 650   
 
 651  1962 
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 652   
 
 653   
 
 654  1962 
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 655  1962 
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 656   
         try {
 657   
             // com\\googlecode\\sparkleg\\Sparql.g:83:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 658   
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 659   
             {
 660   
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 661   
             loop5:
 662   
             do {
 663  4814 
                 int alt5=3;
 664  4814 
                 switch ( input.LA(1) ) {
 665   
                 case BASE:
 666   
                     {
 667  62 
                     alt5=1;
 668   
                     }
 669  62 
                     break;
 670   
                 case PREFIX:
 671   
                     {
 672  2790 
                     alt5=2;
 673   
                     }
 674   
                     break;
 675   
 
 676   
                 }
 677   
 
 678  4814 
                 switch (alt5) {
 679   
                     case 1 :
 680   
                         // com\\googlecode\\sparkleg\\Sparql.g:83:8: baseDecl
 681   
                         {
 682  62 
                         pushFollow(FOLLOW_baseDecl_in_prologue249);
 683  62 
                         baseDecl12=baseDecl();
 684   
 
 685  62 
                         state._fsp--;
 686   
 
 687  62 
                         stream_baseDecl.add(baseDecl12.getTree());
 688   
 
 689   
                         }
 690  62 
                         break;
 691   
                     case 2 :
 692   
                         // com\\googlecode\\sparkleg\\Sparql.g:83:19: prefixDecl
 693   
                         {
 694  2790 
                         pushFollow(FOLLOW_prefixDecl_in_prologue253);
 695  2790 
                         prefixDecl13=prefixDecl();
 696   
 
 697  2790 
                         state._fsp--;
 698   
 
 699  2790 
                         stream_prefixDecl.add(prefixDecl13.getTree());
 700   
 
 701   
                         }
 702  2790 
                         break;
 703   
 
 704   
                     default :
 705  1962 
                         break loop5;
 706   
                 }
 707  2852 
             } while (true);
 708   
 
 709   
 
 710   
             // AST REWRITE
 711   
             // elements: baseDecl, prefixDecl
 712   
             // token labels:
 713   
             // rule labels: retval
 714   
             // token list labels:
 715   
             // rule list labels:
 716   
             // wildcard labels:
 717  1962 
             retval.tree = root_0;
 718  1962 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 719   
 
 720  1962 
             root_0 = (Object)adaptor.nil();
 721   
             // 83:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 722   
             {
 723   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 724   
                 {
 725  1962 
                 Object root_1 = (Object)adaptor.nil();
 726  1962 
                 root_1 = (Object)adaptor.becomeRoot(
 727   
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 728   
                 , root_1);
 729   
 
 730   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:46: ( baseDecl )*
 731  2024 
                 while ( stream_baseDecl.hasNext() ) {
 732  62 
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 733   
 
 734   
                 }
 735  1962 
                 stream_baseDecl.reset();
 736   
 
 737   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:56: ( prefixDecl )*
 738  4752 
                 while ( stream_prefixDecl.hasNext() ) {
 739  2790 
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 740   
 
 741   
                 }
 742  1962 
                 stream_prefixDecl.reset();
 743   
 
 744  1962 
                 adaptor.addChild(root_0, root_1);
 745   
                 }
 746   
 
 747   
             }
 748   
 
 749   
 
 750  1962 
             retval.tree = root_0;
 751   
 
 752   
             }
 753   
 
 754  1962 
             retval.stop = input.LT(-1);
 755   
 
 756   
 
 757  1962 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 758  1962 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 759   
 
 760   
         }
 761  0 
         catch (RecognitionException re) {
 762  0 
             reportError(re);
 763  0 
             recover(input,re);
 764  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 765   
 
 766   
         }
 767   
 
 768  0 
         finally {
 769   
                 // do for sure before leaving
 770  1962 
         }
 771  1962 
         return retval;
 772   
     }
 773   
     // $ANTLR end "prologue"
 774   
 
 775   
 
 776  62 
     public static class baseDecl_return extends ParserRuleReturnScope {
 777   
         Object tree;
 778  62 
         public Object getTree() { return tree; }
 779   
     };
 780   
 
 781   
 
 782   
     // $ANTLR start "baseDecl"
 783   
     // com\\googlecode\\sparkleg\\Sparql.g:86:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 784   
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 785  62 
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 786  62 
         retval.start = input.LT(1);
 787   
 
 788   
 
 789  62 
         Object root_0 = null;
 790   
 
 791  62 
         Token BASE14=null;
 792  62 
         Token IRI_REF15=null;
 793   
 
 794  62 
         Object BASE14_tree=null;
 795  62 
         Object IRI_REF15_tree=null;
 796  62 
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 797  62 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 798   
 
 799   
         try {
 800   
             // com\\googlecode\\sparkleg\\Sparql.g:87:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 801   
             // com\\googlecode\\sparkleg\\Sparql.g:87:7: BASE IRI_REF
 802   
             {
 803  62 
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl284);
 804  62 
             stream_BASE.add(BASE14);
 805   
 
 806   
 
 807  62 
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl286);
 808  62 
             stream_IRI_REF.add(IRI_REF15);
 809   
 
 810   
 
 811   
             // AST REWRITE
 812   
             // elements: BASE, IRI_REF
 813   
             // token labels:
 814   
             // rule labels: retval
 815   
             // token list labels:
 816   
             // rule list labels:
 817   
             // wildcard labels:
 818  62 
             retval.tree = root_0;
 819  62 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 820   
 
 821  62 
             root_0 = (Object)adaptor.nil();
 822   
             // 87:20: -> ^( BASE IRI_REF )
 823   
             {
 824   
                 // com\\googlecode\\sparkleg\\Sparql.g:87:23: ^( BASE IRI_REF )
 825   
                 {
 826  62 
                 Object root_1 = (Object)adaptor.nil();
 827  62 
                 root_1 = (Object)adaptor.becomeRoot(
 828   
                 stream_BASE.nextNode()
 829   
                 , root_1);
 830   
 
 831  62 
                 adaptor.addChild(root_1,
 832   
                 stream_IRI_REF.nextNode()
 833   
                 );
 834   
 
 835  62 
                 adaptor.addChild(root_0, root_1);
 836   
                 }
 837   
 
 838   
             }
 839   
 
 840   
 
 841  62 
             retval.tree = root_0;
 842   
 
 843   
             }
 844   
 
 845  62 
             retval.stop = input.LT(-1);
 846   
 
 847   
 
 848  62 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 849  62 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 850   
 
 851   
         }
 852  0 
         catch (RecognitionException re) {
 853  0 
             reportError(re);
 854  0 
             recover(input,re);
 855  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 856   
 
 857   
         }
 858   
 
 859  0 
         finally {
 860   
                 // do for sure before leaving
 861  62 
         }
 862  62 
         return retval;
 863   
     }
 864   
     // $ANTLR end "baseDecl"
 865   
 
 866   
 
 867  2790 
     public static class prefixDecl_return extends ParserRuleReturnScope {
 868   
         Object tree;
 869  2790 
         public Object getTree() { return tree; }
 870   
     };
 871   
 
 872   
 
 873   
     // $ANTLR start "prefixDecl"
 874   
     // com\\googlecode\\sparkleg\\Sparql.g:90:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 875   
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 876  2790 
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 877  2790 
         retval.start = input.LT(1);
 878   
 
 879   
 
 880  2790 
         Object root_0 = null;
 881   
 
 882  2790 
         Token PREFIX16=null;
 883  2790 
         Token PNAME_NS17=null;
 884  2790 
         Token IRI_REF18=null;
 885   
 
 886  2790 
         Object PREFIX16_tree=null;
 887  2790 
         Object PNAME_NS17_tree=null;
 888  2790 
         Object IRI_REF18_tree=null;
 889  2790 
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 890  2790 
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 891  2790 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 892   
 
 893   
         try {
 894   
             // com\\googlecode\\sparkleg\\Sparql.g:91:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 895   
             // com\\googlecode\\sparkleg\\Sparql.g:91:7: PREFIX PNAME_NS IRI_REF
 896   
             {
 897  2790 
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl312);
 898  2790 
             stream_PREFIX.add(PREFIX16);
 899   
 
 900   
 
 901  2790 
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl314);
 902  2790 
             stream_PNAME_NS.add(PNAME_NS17);
 903   
 
 904   
 
 905  2790 
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl316);
 906  2790 
             stream_IRI_REF.add(IRI_REF18);
 907   
 
 908   
 
 909   
             // AST REWRITE
 910   
             // elements: PREFIX, IRI_REF, PNAME_NS
 911   
             // token labels:
 912   
             // rule labels: retval
 913   
             // token list labels:
 914   
             // rule list labels:
 915   
             // wildcard labels:
 916  2790 
             retval.tree = root_0;
 917  2790 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 918   
 
 919  2790 
             root_0 = (Object)adaptor.nil();
 920   
             // 91:31: -> ^( PREFIX PNAME_NS IRI_REF )
 921   
             {
 922   
                 // com\\googlecode\\sparkleg\\Sparql.g:91:34: ^( PREFIX PNAME_NS IRI_REF )
 923   
                 {
 924  2790 
                 Object root_1 = (Object)adaptor.nil();
 925  2790 
                 root_1 = (Object)adaptor.becomeRoot(
 926   
                 stream_PREFIX.nextNode()
 927   
                 , root_1);
 928   
 
 929  2790 
                 adaptor.addChild(root_1,
 930   
                 stream_PNAME_NS.nextNode()
 931   
                 );
 932   
 
 933  2790 
                 adaptor.addChild(root_1,
 934   
                 stream_IRI_REF.nextNode()
 935   
                 );
 936   
 
 937  2790 
                 adaptor.addChild(root_0, root_1);
 938   
                 }
 939   
 
 940   
             }
 941   
 
 942   
 
 943  2790 
             retval.tree = root_0;
 944   
 
 945   
             }
 946   
 
 947  2790 
             retval.stop = input.LT(-1);
 948   
 
 949   
 
 950  2790 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 951  2790 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 952   
 
 953   
         }
 954  0 
         catch (RecognitionException re) {
 955  0 
             reportError(re);
 956  0 
             recover(input,re);
 957  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 958   
 
 959   
         }
 960   
 
 961  0 
         finally {
 962   
                 // do for sure before leaving
 963  2790 
         }
 964  2790 
         return retval;
 965   
     }
 966   
     // $ANTLR end "prefixDecl"
 967   
 
 968   
 
 969  1614 
     public static class selectQuery_return extends ParserRuleReturnScope {
 970   
         Object tree;
 971  1614 
         public Object getTree() { return tree; }
 972   
     };
 973   
 
 974   
 
 975   
     // $ANTLR start "selectQuery"
 976   
     // com\\googlecode\\sparkleg\\Sparql.g:94:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 977   
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 978  1614 
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 979  1614 
         retval.start = input.LT(1);
 980   
 
 981   
 
 982  1614 
         Object root_0 = null;
 983   
 
 984  1614 
         SparqlParser.selectClause_return selectClause19 =null;
 985   
 
 986  1614 
         SparqlParser.datasetClause_return datasetClause20 =null;
 987   
 
 988  1614 
         SparqlParser.whereClause_return whereClause21 =null;
 989   
 
 990  1614 
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 991   
 
 992   
 
 993  1614 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 994  1614 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 995  1614 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 996  1614 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 997   
         try {
 998   
             // com\\googlecode\\sparkleg\\Sparql.g:95:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 999   
             // com\\googlecode\\sparkleg\\Sparql.g:95:7: selectClause ( datasetClause )* whereClause solutionModifier
 1000   
             {
 1001  1614 
             pushFollow(FOLLOW_selectClause_in_selectQuery343);
 1002  1614 
             selectClause19=selectClause();
 1003   
 
 1004  1614 
             state._fsp--;
 1005   
 
 1006  1614 
             stream_selectClause.add(selectClause19.getTree());
 1007   
 
 1008   
             // com\\googlecode\\sparkleg\\Sparql.g:95:20: ( datasetClause )*
 1009   
             loop6:
 1010   
             do {
 1011  1772 
                 int alt6=2;
 1012  1772 
                 switch ( input.LA(1) ) {
 1013   
                 case FROM:
 1014   
                     {
 1015  158 
                     alt6=1;
 1016   
                     }
 1017   
                     break;
 1018   
 
 1019   
                 }
 1020   
 
 1021  1772 
                 switch (alt6) {
 1022   
                     case 1 :
 1023   
                         // com\\googlecode\\sparkleg\\Sparql.g:95:20: datasetClause
 1024   
                         {
 1025  158 
                         pushFollow(FOLLOW_datasetClause_in_selectQuery345);
 1026  158 
                         datasetClause20=datasetClause();
 1027   
 
 1028  158 
                         state._fsp--;
 1029   
 
 1030  158 
                         stream_datasetClause.add(datasetClause20.getTree());
 1031   
 
 1032   
                         }
 1033  158 
                         break;
 1034   
 
 1035   
                     default :
 1036  1614 
                         break loop6;
 1037   
                 }
 1038  158 
             } while (true);
 1039   
 
 1040   
 
 1041  1614 
             pushFollow(FOLLOW_whereClause_in_selectQuery348);
 1042  1614 
             whereClause21=whereClause();
 1043   
 
 1044  1614 
             state._fsp--;
 1045   
 
 1046  1614 
             stream_whereClause.add(whereClause21.getTree());
 1047   
 
 1048  1614 
             pushFollow(FOLLOW_solutionModifier_in_selectQuery350);
 1049  1614 
             solutionModifier22=solutionModifier();
 1050   
 
 1051  1614 
             state._fsp--;
 1052   
 
 1053  1614 
             stream_solutionModifier.add(solutionModifier22.getTree());
 1054   
 
 1055   
             // AST REWRITE
 1056   
             // elements: solutionModifier, whereClause, datasetClause, selectClause
 1057   
             // token labels:
 1058   
             // rule labels: retval
 1059   
             // token list labels:
 1060   
             // rule list labels:
 1061   
             // wildcard labels:
 1062  1614 
             retval.tree = root_0;
 1063  1614 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1064   
 
 1065  1614 
             root_0 = (Object)adaptor.nil();
 1066   
             // 95:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1067   
             {
 1068   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1069   
                 {
 1070  1614 
                 Object root_1 = (Object)adaptor.nil();
 1071  1614 
                 root_1 = (Object)adaptor.becomeRoot(
 1072   
                 (Object)adaptor.create(SELECT, "SELECT")
 1073   
                 , root_1);
 1074   
 
 1075  1614 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1076   
 
 1077   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:89: ( datasetClause )*
 1078  1772 
                 while ( stream_datasetClause.hasNext() ) {
 1079  158 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1080   
 
 1081   
                 }
 1082  1614 
                 stream_datasetClause.reset();
 1083   
 
 1084   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:104: ( whereClause )*
 1085  3228 
                 while ( stream_whereClause.hasNext() ) {
 1086  1614 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1087   
 
 1088   
                 }
 1089  1614 
                 stream_whereClause.reset();
 1090   
 
 1091   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:117: ( solutionModifier )*
 1092  1802 
                 while ( stream_solutionModifier.hasNext() ) {
 1093  188 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1094   
 
 1095   
                 }
 1096  1614 
                 stream_solutionModifier.reset();
 1097   
 
 1098  1614 
                 adaptor.addChild(root_0, root_1);
 1099   
                 }
 1100   
 
 1101   
             }
 1102   
 
 1103   
 
 1104  1614 
             retval.tree = root_0;
 1105   
 
 1106   
             }
 1107   
 
 1108  1614 
             retval.stop = input.LT(-1);
 1109   
 
 1110   
 
 1111  1614 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1112  1614 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1113   
 
 1114   
         }
 1115  0 
         catch (RecognitionException re) {
 1116  0 
             reportError(re);
 1117  0 
             recover(input,re);
 1118  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1119   
 
 1120   
         }
 1121   
 
 1122  0 
         finally {
 1123   
                 // do for sure before leaving
 1124  1614 
         }
 1125  1614 
         return retval;
 1126   
     }
 1127   
     // $ANTLR end "selectQuery"
 1128   
 
 1129   
 
 1130  46 
     public static class subSelect_return extends ParserRuleReturnScope {
 1131   
         Object tree;
 1132  46 
         public Object getTree() { return tree; }
 1133   
     };
 1134   
 
 1135   
 
 1136   
     // $ANTLR start "subSelect"
 1137   
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1138   
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1139  46 
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1140  46 
         retval.start = input.LT(1);
 1141   
 
 1142   
 
 1143  46 
         Object root_0 = null;
 1144   
 
 1145  46 
         SparqlParser.selectClause_return selectClause23 =null;
 1146   
 
 1147  46 
         SparqlParser.whereClause_return whereClause24 =null;
 1148   
 
 1149  46 
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1150   
 
 1151   
 
 1152  46 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1153  46 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1154  46 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1155   
         try {
 1156   
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1157   
             // com\\googlecode\\sparkleg\\Sparql.g:99:7: selectClause whereClause solutionModifier
 1158   
             {
 1159  46 
             pushFollow(FOLLOW_selectClause_in_subSelect384);
 1160  46 
             selectClause23=selectClause();
 1161   
 
 1162  46 
             state._fsp--;
 1163   
 
 1164  46 
             stream_selectClause.add(selectClause23.getTree());
 1165   
 
 1166  46 
             pushFollow(FOLLOW_whereClause_in_subSelect386);
 1167  46 
             whereClause24=whereClause();
 1168   
 
 1169  46 
             state._fsp--;
 1170   
 
 1171  46 
             stream_whereClause.add(whereClause24.getTree());
 1172   
 
 1173  46 
             pushFollow(FOLLOW_solutionModifier_in_subSelect388);
 1174  46 
             solutionModifier25=solutionModifier();
 1175   
 
 1176  46 
             state._fsp--;
 1177   
 
 1178  46 
             stream_solutionModifier.add(solutionModifier25.getTree());
 1179   
 
 1180   
             // AST REWRITE
 1181   
             // elements: whereClause, selectClause, solutionModifier
 1182   
             // token labels:
 1183   
             // rule labels: retval
 1184   
             // token list labels:
 1185   
             // rule list labels:
 1186   
             // wildcard labels:
 1187  46 
             retval.tree = root_0;
 1188  46 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1189   
 
 1190  46 
             root_0 = (Object)adaptor.nil();
 1191   
             // 99:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1192   
             {
 1193   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1194   
                 {
 1195  46 
                 Object root_1 = (Object)adaptor.nil();
 1196  46 
                 root_1 = (Object)adaptor.becomeRoot(
 1197   
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1198   
                 , root_1);
 1199   
 
 1200  46 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1201   
 
 1202   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:77: ( whereClause )*
 1203  92 
                 while ( stream_whereClause.hasNext() ) {
 1204  46 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1205   
 
 1206   
                 }
 1207  46 
                 stream_whereClause.reset();
 1208   
 
 1209   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:90: ( solutionModifier )*
 1210  56 
                 while ( stream_solutionModifier.hasNext() ) {
 1211  10 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1212   
 
 1213   
                 }
 1214  46 
                 stream_solutionModifier.reset();
 1215   
 
 1216  46 
                 adaptor.addChild(root_0, root_1);
 1217   
                 }
 1218   
 
 1219   
             }
 1220   
 
 1221   
 
 1222  46 
             retval.tree = root_0;
 1223   
 
 1224   
             }
 1225   
 
 1226  46 
             retval.stop = input.LT(-1);
 1227   
 
 1228   
 
 1229  46 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1230  46 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1231   
 
 1232   
         }
 1233  0 
         catch (RecognitionException re) {
 1234  0 
             reportError(re);
 1235  0 
             recover(input,re);
 1236  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1237   
 
 1238   
         }
 1239   
 
 1240  0 
         finally {
 1241   
                 // do for sure before leaving
 1242  46 
         }
 1243  46 
         return retval;
 1244   
     }
 1245   
     // $ANTLR end "subSelect"
 1246   
 
 1247   
 
 1248  1660 
     public static class selectClause_return extends ParserRuleReturnScope {
 1249   
         Object tree;
 1250  1660 
         public Object getTree() { return tree; }
 1251   
     };
 1252   
 
 1253   
 
 1254   
     // $ANTLR start "selectClause"
 1255   
     // com\\googlecode\\sparkleg\\Sparql.g:102:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1256   
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1257  1660 
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1258  1660 
         retval.start = input.LT(1);
 1259   
 
 1260   
 
 1261  1660 
         Object root_0 = null;
 1262   
 
 1263  1660 
         Token SELECT26=null;
 1264  1660 
         Token DISTINCT27=null;
 1265  1660 
         Token REDUCED28=null;
 1266  1660 
         Token ASTERISK29=null;
 1267  1660 
         Token SELECT30=null;
 1268  1660 
         Token DISTINCT31=null;
 1269  1660 
         Token REDUCED32=null;
 1270  1660 
         List list_v=null;
 1271  1660 
         RuleReturnScope v = null;
 1272  1660 
         Object SELECT26_tree=null;
 1273  1660 
         Object DISTINCT27_tree=null;
 1274  1660 
         Object REDUCED28_tree=null;
 1275  1660 
         Object ASTERISK29_tree=null;
 1276  1660 
         Object SELECT30_tree=null;
 1277  1660 
         Object DISTINCT31_tree=null;
 1278  1660 
         Object REDUCED32_tree=null;
 1279  1660 
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1280  1660 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1281  1660 
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1282  1660 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1283  1660 
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1284   
         try {
 1285   
             // com\\googlecode\\sparkleg\\Sparql.g:103:5: ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1286  1660 
             int alt10=2;
 1287  1660 
             switch ( input.LA(1) ) {
 1288   
             case SELECT:
 1289   
                 {
 1290  1660 
                 switch ( input.LA(2) ) {
 1291   
                 case DISTINCT:
 1292   
                     {
 1293  44 
                     switch ( input.LA(3) ) {
 1294   
                     case ASTERISK:
 1295   
                         {
 1296  2 
                         alt10=1;
 1297   
                         }
 1298  2 
                         break;
 1299   
                     case OPEN_BRACE:
 1300   
                     case VAR1:
 1301   
                     case VAR2:
 1302   
                         {
 1303  42 
                         alt10=2;
 1304   
                         }
 1305  42 
                         break;
 1306   
                     default:
 1307  0 
                         NoViableAltException nvae =
 1308   
                             new NoViableAltException("", 10, 2, input);
 1309   
 
 1310  0 
                         throw nvae;
 1311   
 
 1312   
                     }
 1313   
 
 1314   
                     }
 1315  44 
                     break;
 1316   
                 case REDUCED:
 1317   
                     {
 1318  14 
                     switch ( input.LA(3) ) {
 1319   
                     case ASTERISK:
 1320   
                         {
 1321  4 
                         alt10=1;
 1322   
                         }
 1323  4 
                         break;
 1324   
                     case OPEN_BRACE:
 1325   
                     case VAR1:
 1326   
                     case VAR2:
 1327   
                         {
 1328  10 
                         alt10=2;
 1329   
                         }
 1330  10 
                         break;
 1331   
                     default:
 1332  0 
                         NoViableAltException nvae =
 1333   
                             new NoViableAltException("", 10, 3, input);
 1334   
 
 1335  0 
                         throw nvae;
 1336   
 
 1337   
                     }
 1338   
 
 1339   
                     }
 1340  14 
                     break;
 1341   
                 case ASTERISK:
 1342   
                     {
 1343  680 
                     alt10=1;
 1344   
                     }
 1345  680 
                     break;
 1346   
                 case OPEN_BRACE:
 1347   
                 case VAR1:
 1348   
                 case VAR2:
 1349   
                     {
 1350  922 
                     alt10=2;
 1351   
                     }
 1352  922 
                     break;
 1353   
                 default:
 1354  0 
                     NoViableAltException nvae =
 1355   
                         new NoViableAltException("", 10, 1, input);
 1356   
 
 1357  0 
                     throw nvae;
 1358   
 
 1359   
                 }
 1360   
 
 1361   
                 }
 1362  1660 
                 break;
 1363   
             default:
 1364  0 
                 NoViableAltException nvae =
 1365   
                     new NoViableAltException("", 10, 0, input);
 1366   
 
 1367  0 
                 throw nvae;
 1368   
 
 1369   
             }
 1370   
 
 1371  1660 
             switch (alt10) {
 1372   
                 case 1 :
 1373   
                     // com\\googlecode\\sparkleg\\Sparql.g:103:7: SELECT ( DISTINCT | REDUCED )? ASTERISK
 1374   
                     {
 1375  686 
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause424);
 1376  686 
                     stream_SELECT.add(SELECT26);
 1377   
 
 1378   
 
 1379   
                     // com\\googlecode\\sparkleg\\Sparql.g:103:14: ( DISTINCT | REDUCED )?
 1380  686 
                     int alt7=3;
 1381  686 
                     switch ( input.LA(1) ) {
 1382   
                         case DISTINCT:
 1383   
                             {
 1384  2 
                             alt7=1;
 1385   
                             }
 1386  2 
                             break;
 1387   
                         case REDUCED:
 1388   
                             {
 1389  4 
                             alt7=2;
 1390   
                             }
 1391   
                             break;
 1392   
                     }
 1393   
 
 1394  686 
                     switch (alt7) {
 1395   
                         case 1 :
 1396   
                             // com\\googlecode\\sparkleg\\Sparql.g:103:15: DISTINCT
 1397   
                             {
 1398  2 
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause427);
 1399  2 
                             stream_DISTINCT.add(DISTINCT27);
 1400   
 
 1401   
 
 1402   
                             }
 1403  2 
                             break;
 1404   
                         case 2 :
 1405   
                             // com\\googlecode\\sparkleg\\Sparql.g:103:26: REDUCED
 1406   
                             {
 1407  4 
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause431);
 1408  4 
                             stream_REDUCED.add(REDUCED28);
 1409   
 
 1410   
 
 1411   
                             }
 1412   
                             break;
 1413   
 
 1414   
                     }
 1415   
 
 1416   
 
 1417  686 
                     ASTERISK29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause435);
 1418  686 
                     stream_ASTERISK.add(ASTERISK29);
 1419   
 
 1420   
 
 1421   
                     // AST REWRITE
 1422   
                     // elements: DISTINCT, REDUCED, ASTERISK
 1423   
                     // token labels:
 1424   
                     // rule labels: retval
 1425   
                     // token list labels:
 1426   
                     // rule list labels:
 1427   
                     // wildcard labels:
 1428  686 
                     retval.tree = root_0;
 1429  686 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1430   
 
 1431  686 
                     root_0 = (Object)adaptor.nil();
 1432   
                     // 103:45: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1433   
                     {
 1434   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:48: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1435   
                         {
 1436  686 
                         Object root_1 = (Object)adaptor.nil();
 1437  686 
                         root_1 = (Object)adaptor.becomeRoot(
 1438   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1439   
                         , root_1);
 1440   
 
 1441   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:64: ( DISTINCT )*
 1442  688 
                         while ( stream_DISTINCT.hasNext() ) {
 1443  2 
                             adaptor.addChild(root_1,
 1444   
                             stream_DISTINCT.nextNode()
 1445   
                             );
 1446   
 
 1447   
                         }
 1448  686 
                         stream_DISTINCT.reset();
 1449   
 
 1450   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:74: ( REDUCED )*
 1451  690 
                         while ( stream_REDUCED.hasNext() ) {
 1452  4 
                             adaptor.addChild(root_1,
 1453   
                             stream_REDUCED.nextNode()
 1454   
                             );
 1455   
 
 1456   
                         }
 1457  686 
                         stream_REDUCED.reset();
 1458   
 
 1459  686 
                         adaptor.addChild(root_1,
 1460   
                         stream_ASTERISK.nextNode()
 1461   
                         );
 1462   
 
 1463  686 
                         adaptor.addChild(root_0, root_1);
 1464   
                         }
 1465   
 
 1466   
                     }
 1467   
 
 1468   
 
 1469  686 
                     retval.tree = root_0;
 1470   
 
 1471   
                     }
 1472  686 
                     break;
 1473   
                 case 2 :
 1474   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1475   
                     {
 1476  974 
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause457);
 1477  974 
                     stream_SELECT.add(SELECT30);
 1478   
 
 1479   
 
 1480   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:14: ( DISTINCT | REDUCED )?
 1481  974 
                     int alt8=3;
 1482  974 
                     switch ( input.LA(1) ) {
 1483   
                         case DISTINCT:
 1484   
                             {
 1485  42 
                             alt8=1;
 1486   
                             }
 1487  42 
                             break;
 1488   
                         case REDUCED:
 1489   
                             {
 1490  10 
                             alt8=2;
 1491   
                             }
 1492   
                             break;
 1493   
                     }
 1494   
 
 1495  974 
                     switch (alt8) {
 1496   
                         case 1 :
 1497   
                             // com\\googlecode\\sparkleg\\Sparql.g:104:15: DISTINCT
 1498   
                             {
 1499  42 
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause460);
 1500  42 
                             stream_DISTINCT.add(DISTINCT31);
 1501   
 
 1502   
 
 1503   
                             }
 1504  42 
                             break;
 1505   
                         case 2 :
 1506   
                             // com\\googlecode\\sparkleg\\Sparql.g:104:26: REDUCED
 1507   
                             {
 1508  10 
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause464);
 1509  10 
                             stream_REDUCED.add(REDUCED32);
 1510   
 
 1511   
 
 1512   
                             }
 1513   
                             break;
 1514   
 
 1515   
                     }
 1516   
 
 1517   
 
 1518   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:36: (v+= selectVariables )+
 1519  974 
                     int cnt9=0;
 1520   
                     loop9:
 1521   
                     do {
 1522  2630 
                         int alt9=2;
 1523  2630 
                         switch ( input.LA(1) ) {
 1524   
                         case OPEN_BRACE:
 1525   
                         case VAR1:
 1526   
                         case VAR2:
 1527   
                             {
 1528  1656 
                             alt9=1;
 1529   
                             }
 1530   
                             break;
 1531   
 
 1532   
                         }
 1533   
 
 1534  2630 
                         switch (alt9) {
 1535   
                             case 1 :
 1536   
                                 // com\\googlecode\\sparkleg\\Sparql.g:104:37: v+= selectVariables
 1537   
                                 {
 1538  1656 
                                 pushFollow(FOLLOW_selectVariables_in_selectClause471);
 1539  1656 
                                 v=selectVariables();
 1540   
 
 1541  1656 
                                 state._fsp--;
 1542   
 
 1543  1656 
                                 stream_selectVariables.add(v.getTree());
 1544  1656 
                                 if (list_v==null) list_v=new ArrayList();
 1545  1656 
                                 list_v.add(v.getTree());
 1546   
 
 1547   
 
 1548   
                                 }
 1549  1656 
                                 break;
 1550   
 
 1551   
                             default :
 1552  974 
                                 if ( cnt9 >= 1 ) break loop9;
 1553  0 
                                 EarlyExitException eee =
 1554   
                                     new EarlyExitException(9, input);
 1555  0 
                                 throw eee;
 1556   
                         }
 1557  1656 
                         cnt9++;
 1558  1656 
                     } while (true);
 1559   
 
 1560   
 
 1561   
                     // AST REWRITE
 1562   
                     // elements: REDUCED, DISTINCT, v
 1563   
                     // token labels:
 1564   
                     // rule labels: retval
 1565   
                     // token list labels:
 1566   
                     // rule list labels: v
 1567   
                     // wildcard labels:
 1568  974 
                     retval.tree = root_0;
 1569  974 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1570  974 
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1571  974 
                     root_0 = (Object)adaptor.nil();
 1572   
                     // 104:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1573   
                     {
 1574   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1575   
                         {
 1576  974 
                         Object root_1 = (Object)adaptor.nil();
 1577  974 
                         root_1 = (Object)adaptor.becomeRoot(
 1578   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1579   
                         , root_1);
 1580   
 
 1581   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:77: ( DISTINCT )*
 1582  1016 
                         while ( stream_DISTINCT.hasNext() ) {
 1583  42 
                             adaptor.addChild(root_1,
 1584   
                             stream_DISTINCT.nextNode()
 1585   
                             );
 1586   
 
 1587   
                         }
 1588  974 
                         stream_DISTINCT.reset();
 1589   
 
 1590   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:87: ( REDUCED )*
 1591  984 
                         while ( stream_REDUCED.hasNext() ) {
 1592  10 
                             adaptor.addChild(root_1,
 1593   
                             stream_REDUCED.nextNode()
 1594   
                             );
 1595   
 
 1596   
                         }
 1597  974 
                         stream_REDUCED.reset();
 1598   
 
 1599   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:97: ( $v)*
 1600  2630 
                         while ( stream_v.hasNext() ) {
 1601  1656 
                             adaptor.addChild(root_1, stream_v.nextTree());
 1602   
 
 1603   
                         }
 1604  974 
                         stream_v.reset();
 1605   
 
 1606  974 
                         adaptor.addChild(root_0, root_1);
 1607   
                         }
 1608   
 
 1609   
                     }
 1610   
 
 1611   
 
 1612  974 
                     retval.tree = root_0;
 1613   
 
 1614   
                     }
 1615   
                     break;
 1616   
 
 1617   
             }
 1618  1660 
             retval.stop = input.LT(-1);
 1619   
 
 1620   
 
 1621  1660 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1622  1660 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1623   
 
 1624   
         }
 1625  0 
         catch (RecognitionException re) {
 1626  0 
             reportError(re);
 1627  0 
             recover(input,re);
 1628  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1629   
 
 1630   
         }
 1631   
 
 1632  0 
         finally {
 1633   
                 // do for sure before leaving
 1634  1660 
         }
 1635  1660 
         return retval;
 1636   
     }
 1637   
     // $ANTLR end "selectClause"
 1638   
 
 1639   
 
 1640  1656 
     public static class selectVariables_return extends ParserRuleReturnScope {
 1641   
         Object tree;
 1642  3312 
         public Object getTree() { return tree; }
 1643   
     };
 1644   
 
 1645   
 
 1646   
     // $ANTLR start "selectVariables"
 1647   
     // com\\googlecode\\sparkleg\\Sparql.g:107:1: selectVariables : ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) );
 1648   
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1649  1656 
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1650  1656 
         retval.start = input.LT(1);
 1651   
 
 1652   
 
 1653  1656 
         Object root_0 = null;
 1654   
 
 1655  1656 
         Token OPEN_BRACE34=null;
 1656  1656 
         Token AS36=null;
 1657  1656 
         Token CLOSE_BRACE38=null;
 1658  1656 
         SparqlParser.var_return var33 =null;
 1659   
 
 1660  1656 
         SparqlParser.expression_return expression35 =null;
 1661   
 
 1662  1656 
         SparqlParser.var_return var37 =null;
 1663   
 
 1664   
 
 1665  1656 
         Object OPEN_BRACE34_tree=null;
 1666  1656 
         Object AS36_tree=null;
 1667  1656 
         Object CLOSE_BRACE38_tree=null;
 1668  1656 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1669  1656 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 1670  1656 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 1671  1656 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1672  1656 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1673   
         try {
 1674   
             // com\\googlecode\\sparkleg\\Sparql.g:108:5: ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) )
 1675  1656 
             int alt11=2;
 1676  1656 
             switch ( input.LA(1) ) {
 1677   
             case VAR1:
 1678   
             case VAR2:
 1679   
                 {
 1680  1406 
                 alt11=1;
 1681   
                 }
 1682  1406 
                 break;
 1683   
             case OPEN_BRACE:
 1684   
                 {
 1685  250 
                 alt11=2;
 1686   
                 }
 1687  250 
                 break;
 1688   
             default:
 1689  0 
                 NoViableAltException nvae =
 1690   
                     new NoViableAltException("", 11, 0, input);
 1691   
 
 1692  0 
                 throw nvae;
 1693   
 
 1694   
             }
 1695   
 
 1696  1656 
             switch (alt11) {
 1697   
                 case 1 :
 1698   
                     // com\\googlecode\\sparkleg\\Sparql.g:108:7: var
 1699   
                     {
 1700  1406 
                     pushFollow(FOLLOW_var_in_selectVariables506);
 1701  1406 
                     var33=var();
 1702   
 
 1703  1406 
                     state._fsp--;
 1704   
 
 1705  1406 
                     stream_var.add(var33.getTree());
 1706   
 
 1707   
                     // AST REWRITE
 1708   
                     // elements: var
 1709   
                     // token labels:
 1710   
                     // rule labels: retval
 1711   
                     // token list labels:
 1712   
                     // rule list labels:
 1713   
                     // wildcard labels:
 1714  1406 
                     retval.tree = root_0;
 1715  1406 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1716   
 
 1717  1406 
                     root_0 = (Object)adaptor.nil();
 1718   
                     // 108:11: -> ^( VAR var )
 1719   
                     {
 1720   
                         // com\\googlecode\\sparkleg\\Sparql.g:108:14: ^( VAR var )
 1721   
                         {
 1722  1406 
                         Object root_1 = (Object)adaptor.nil();
 1723  1406 
                         root_1 = (Object)adaptor.becomeRoot(
 1724   
                         (Object)adaptor.create(VAR, "VAR")
 1725   
                         , root_1);
 1726   
 
 1727  1406 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1728   
 
 1729  1406 
                         adaptor.addChild(root_0, root_1);
 1730   
                         }
 1731   
 
 1732   
                     }
 1733   
 
 1734   
 
 1735  1406 
                     retval.tree = root_0;
 1736   
 
 1737   
                     }
 1738  1406 
                     break;
 1739   
                 case 2 :
 1740   
                     // com\\googlecode\\sparkleg\\Sparql.g:109:7: OPEN_BRACE expression AS var CLOSE_BRACE
 1741   
                     {
 1742  250 
                     OPEN_BRACE34=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_selectVariables523);
 1743  250 
                     stream_OPEN_BRACE.add(OPEN_BRACE34);
 1744   
 
 1745   
 
 1746  250 
                     pushFollow(FOLLOW_expression_in_selectVariables525);
 1747  250 
                     expression35=expression();
 1748   
 
 1749  250 
                     state._fsp--;
 1750   
 
 1751  250 
                     stream_expression.add(expression35.getTree());
 1752   
 
 1753  250 
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables527);
 1754  250 
                     stream_AS.add(AS36);
 1755   
 
 1756   
 
 1757  250 
                     pushFollow(FOLLOW_var_in_selectVariables529);
 1758  250 
                     var37=var();
 1759   
 
 1760  250 
                     state._fsp--;
 1761   
 
 1762  250 
                     stream_var.add(var37.getTree());
 1763   
 
 1764  250 
                     CLOSE_BRACE38=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_selectVariables531);
 1765  250 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE38);
 1766   
 
 1767   
 
 1768   
                     // AST REWRITE
 1769   
                     // elements: expression, AS, var
 1770   
                     // token labels:
 1771   
                     // rule labels: retval
 1772   
                     // token list labels:
 1773   
                     // rule list labels:
 1774   
                     // wildcard labels:
 1775  250 
                     retval.tree = root_0;
 1776  250 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1777   
 
 1778  250 
                     root_0 = (Object)adaptor.nil();
 1779   
                     // 109:48: -> ^( AS expression var )
 1780   
                     {
 1781   
                         // com\\googlecode\\sparkleg\\Sparql.g:109:51: ^( AS expression var )
 1782   
                         {
 1783  250 
                         Object root_1 = (Object)adaptor.nil();
 1784  250 
                         root_1 = (Object)adaptor.becomeRoot(
 1785   
                         stream_AS.nextNode()
 1786   
                         , root_1);
 1787   
 
 1788  250 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1789   
 
 1790  250 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1791   
 
 1792  250 
                         adaptor.addChild(root_0, root_1);
 1793   
                         }
 1794   
 
 1795   
                     }
 1796   
 
 1797   
 
 1798  250 
                     retval.tree = root_0;
 1799   
 
 1800   
                     }
 1801   
                     break;
 1802   
 
 1803   
             }
 1804  1656 
             retval.stop = input.LT(-1);
 1805   
 
 1806   
 
 1807  1656 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1808  1656 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1809   
 
 1810   
         }
 1811  0 
         catch (RecognitionException re) {
 1812  0 
             reportError(re);
 1813  0 
             recover(input,re);
 1814  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1815   
 
 1816   
         }
 1817   
 
 1818  0 
         finally {
 1819   
                 // do for sure before leaving
 1820  1656 
         }
 1821  1656 
         return retval;
 1822   
     }
 1823   
     // $ANTLR end "selectVariables"
 1824   
 
 1825   
 
 1826  72 
     public static class constructQuery_return extends ParserRuleReturnScope {
 1827   
         Object tree;
 1828  72 
         public Object getTree() { return tree; }
 1829   
     };
 1830   
 
 1831   
 
 1832   
     // $ANTLR start "constructQuery"
 1833   
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) );
 1834   
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1835  72 
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1836  72 
         retval.start = input.LT(1);
 1837   
 
 1838   
 
 1839  72 
         Object root_0 = null;
 1840   
 
 1841  72 
         Token CONSTRUCT39=null;
 1842  72 
         Token CONSTRUCT44=null;
 1843  72 
         Token WHERE46=null;
 1844  72 
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1845   
 
 1846  72 
         SparqlParser.datasetClause_return datasetClause41 =null;
 1847   
 
 1848  72 
         SparqlParser.whereClause_return whereClause42 =null;
 1849   
 
 1850  72 
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1851   
 
 1852  72 
         SparqlParser.datasetClause_return datasetClause45 =null;
 1853   
 
 1854  72 
         SparqlParser.groupGraphPattern_return groupGraphPattern47 =null;
 1855   
 
 1856  72 
         SparqlParser.solutionModifier_return solutionModifier48 =null;
 1857   
 
 1858   
 
 1859  72 
         Object CONSTRUCT39_tree=null;
 1860  72 
         Object CONSTRUCT44_tree=null;
 1861  72 
         Object WHERE46_tree=null;
 1862  72 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1863  72 
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1864  72 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1865  72 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1866  72 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 1867  72 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1868  72 
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1869   
         try {
 1870   
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) )
 1871  72 
             int alt14=2;
 1872  72 
             switch ( input.LA(1) ) {
 1873   
             case CONSTRUCT:
 1874   
                 {
 1875  72 
                 switch ( input.LA(2) ) {
 1876   
                 case OPEN_CURLY_BRACE:
 1877   
                     {
 1878  54 
                     alt14=1;
 1879   
                     }
 1880  54 
                     break;
 1881   
                 case FROM:
 1882   
                 case WHERE:
 1883   
                     {
 1884  16 
                     alt14=2;
 1885   
                     }
 1886  16 
                     break;
 1887   
                 default:
 1888  2 
                     NoViableAltException nvae =
 1889   
                         new NoViableAltException("", 14, 1, input);
 1890   
 
 1891  2 
                     throw nvae;
 1892   
 
 1893   
                 }
 1894   
 
 1895   
                 }
 1896  70 
                 break;
 1897   
             default:
 1898  0 
                 NoViableAltException nvae =
 1899   
                     new NoViableAltException("", 14, 0, input);
 1900   
 
 1901  0 
                 throw nvae;
 1902   
 
 1903   
             }
 1904   
 
 1905  70 
             switch (alt14) {
 1906   
                 case 1 :
 1907   
                     // com\\googlecode\\sparkleg\\Sparql.g:113:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1908   
                     {
 1909  54 
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery558);
 1910  54 
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1911   
 
 1912   
 
 1913  54 
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery560);
 1914  54 
                     constructTemplate40=constructTemplate();
 1915   
 
 1916  54 
                     state._fsp--;
 1917   
 
 1918  54 
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1919   
 
 1920   
                     // com\\googlecode\\sparkleg\\Sparql.g:113:35: ( datasetClause )*
 1921   
                     loop12:
 1922   
                     do {
 1923  54 
                         int alt12=2;
 1924  54 
                         switch ( input.LA(1) ) {
 1925   
                         case FROM:
 1926   
                             {
 1927  0 
                             alt12=1;
 1928   
                             }
 1929   
                             break;
 1930   
 
 1931   
                         }
 1932   
 
 1933  54 
                         switch (alt12) {
 1934   
                             case 1 :
 1935   
                                 // com\\googlecode\\sparkleg\\Sparql.g:113:35: datasetClause
 1936   
                                 {
 1937  0 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery562);
 1938  0 
                                 datasetClause41=datasetClause();
 1939   
 
 1940  0 
                                 state._fsp--;
 1941   
 
 1942  0 
                                 stream_datasetClause.add(datasetClause41.getTree());
 1943   
 
 1944   
                                 }
 1945  0 
                                 break;
 1946   
 
 1947   
                             default :
 1948  54 
                                 break loop12;
 1949   
                         }
 1950  0 
                     } while (true);
 1951   
 
 1952   
 
 1953  54 
                     pushFollow(FOLLOW_whereClause_in_constructQuery565);
 1954  54 
                     whereClause42=whereClause();
 1955   
 
 1956  54 
                     state._fsp--;
 1957   
 
 1958  54 
                     stream_whereClause.add(whereClause42.getTree());
 1959   
 
 1960  54 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery567);
 1961  54 
                     solutionModifier43=solutionModifier();
 1962   
 
 1963  54 
                     state._fsp--;
 1964   
 
 1965  54 
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1966   
 
 1967   
                     // AST REWRITE
 1968   
                     // elements: datasetClause, CONSTRUCT, solutionModifier, constructTemplate, whereClause
 1969   
                     // token labels:
 1970   
                     // rule labels: retval
 1971   
                     // token list labels:
 1972   
                     // rule list labels:
 1973   
                     // wildcard labels:
 1974  54 
                     retval.tree = root_0;
 1975  54 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1976   
 
 1977  54 
                     root_0 = (Object)adaptor.nil();
 1978   
                     // 113:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1979   
                     {
 1980   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1981   
                         {
 1982  54 
                         Object root_1 = (Object)adaptor.nil();
 1983  54 
                         root_1 = (Object)adaptor.becomeRoot(
 1984   
                         stream_CONSTRUCT.nextNode()
 1985   
                         , root_1);
 1986   
 
 1987  54 
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 1988   
 
 1989   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:112: ( datasetClause )*
 1990  54 
                         while ( stream_datasetClause.hasNext() ) {
 1991  0 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1992   
 
 1993   
                         }
 1994  54 
                         stream_datasetClause.reset();
 1995   
 
 1996   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:127: ( whereClause )*
 1997  108 
                         while ( stream_whereClause.hasNext() ) {
 1998  54 
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 1999   
 
 2000   
                         }
 2001  54 
                         stream_whereClause.reset();
 2002   
 
 2003   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:140: ( solutionModifier )*
 2004  60 
                         while ( stream_solutionModifier.hasNext() ) {
 2005  6 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2006   
 
 2007   
                         }
 2008  54 
                         stream_solutionModifier.reset();
 2009   
 
 2010  54 
                         adaptor.addChild(root_0, root_1);
 2011   
                         }
 2012   
 
 2013   
                     }
 2014   
 
 2015   
 
 2016  54 
                     retval.tree = root_0;
 2017   
 
 2018   
                     }
 2019  54 
                     break;
 2020   
                 case 2 :
 2021   
                     // com\\googlecode\\sparkleg\\Sparql.g:114:7: CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier
 2022   
                     {
 2023  16 
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery592);
 2024  16 
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2025   
 
 2026   
 
 2027   
                     // com\\googlecode\\sparkleg\\Sparql.g:114:17: ( datasetClause )*
 2028   
                     loop13:
 2029   
                     do {
 2030  18 
                         int alt13=2;
 2031  18 
                         switch ( input.LA(1) ) {
 2032   
                         case FROM:
 2033   
                             {
 2034  2 
                             alt13=1;
 2035   
                             }
 2036   
                             break;
 2037   
 
 2038   
                         }
 2039   
 
 2040  18 
                         switch (alt13) {
 2041   
                             case 1 :
 2042   
                                 // com\\googlecode\\sparkleg\\Sparql.g:114:17: datasetClause
 2043   
                                 {
 2044  2 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery594);
 2045  2 
                                 datasetClause45=datasetClause();
 2046   
 
 2047  2 
                                 state._fsp--;
 2048   
 
 2049  2 
                                 stream_datasetClause.add(datasetClause45.getTree());
 2050   
 
 2051   
                                 }
 2052  2 
                                 break;
 2053   
 
 2054   
                             default :
 2055  16 
                                 break loop13;
 2056   
                         }
 2057  2 
                     } while (true);
 2058   
 
 2059   
 
 2060  16 
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery597);
 2061  16 
                     stream_WHERE.add(WHERE46);
 2062   
 
 2063   
 
 2064  16 
                     pushFollow(FOLLOW_groupGraphPattern_in_constructQuery599);
 2065  16 
                     groupGraphPattern47=groupGraphPattern();
 2066   
 
 2067  16 
                     state._fsp--;
 2068   
 
 2069  16 
                     stream_groupGraphPattern.add(groupGraphPattern47.getTree());
 2070   
 
 2071  16 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery601);
 2072  16 
                     solutionModifier48=solutionModifier();
 2073   
 
 2074  16 
                     state._fsp--;
 2075   
 
 2076  16 
                     stream_solutionModifier.add(solutionModifier48.getTree());
 2077   
 
 2078   
                     // AST REWRITE
 2079   
                     // elements: CONSTRUCT, solutionModifier, datasetClause, groupGraphPattern
 2080   
                     // token labels:
 2081   
                     // rule labels: retval
 2082   
                     // token list labels:
 2083   
                     // rule list labels:
 2084   
                     // wildcard labels:
 2085  16 
                     retval.tree = root_0;
 2086  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2087   
 
 2088  16 
                     root_0 = (Object)adaptor.nil();
 2089   
                     // 114:73: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2090   
                     {
 2091   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:76: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2092   
                         {
 2093  16 
                         Object root_1 = (Object)adaptor.nil();
 2094  16 
                         root_1 = (Object)adaptor.becomeRoot(
 2095   
                         stream_CONSTRUCT.nextNode()
 2096   
                         , root_1);
 2097   
 
 2098   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:88: ( datasetClause )*
 2099  18 
                         while ( stream_datasetClause.hasNext() ) {
 2100  2 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2101   
 
 2102   
                         }
 2103  16 
                         stream_datasetClause.reset();
 2104   
 
 2105   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:103: ^( WHERE_CLAUSE ( groupGraphPattern )* )
 2106   
                         {
 2107  16 
                         Object root_2 = (Object)adaptor.nil();
 2108  16 
                         root_2 = (Object)adaptor.becomeRoot(
 2109   
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2110   
                         , root_2);
 2111   
 
 2112   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:118: ( groupGraphPattern )*
 2113  32 
                         while ( stream_groupGraphPattern.hasNext() ) {
 2114  16 
                             adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 2115   
 
 2116   
                         }
 2117  16 
                         stream_groupGraphPattern.reset();
 2118   
 
 2119  16 
                         adaptor.addChild(root_1, root_2);
 2120   
                         }
 2121   
 
 2122   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:138: ( solutionModifier )*
 2123  16 
                         while ( stream_solutionModifier.hasNext() ) {
 2124  0 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2125   
 
 2126   
                         }
 2127  16 
                         stream_solutionModifier.reset();
 2128   
 
 2129  16 
                         adaptor.addChild(root_0, root_1);
 2130   
                         }
 2131   
 
 2132   
                     }
 2133   
 
 2134   
 
 2135  16 
                     retval.tree = root_0;
 2136   
 
 2137   
                     }
 2138   
                     break;
 2139   
 
 2140   
             }
 2141  70 
             retval.stop = input.LT(-1);
 2142   
 
 2143   
 
 2144  70 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2145  70 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2146   
 
 2147   
         }
 2148  2 
         catch (RecognitionException re) {
 2149  2 
             reportError(re);
 2150  2 
             recover(input,re);
 2151  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2152   
 
 2153   
         }
 2154   
 
 2155  0 
         finally {
 2156   
                 // do for sure before leaving
 2157  72 
         }
 2158  72 
         return retval;
 2159   
     }
 2160   
     // $ANTLR end "constructQuery"
 2161   
 
 2162   
 
 2163  28 
     public static class describeQuery_return extends ParserRuleReturnScope {
 2164   
         Object tree;
 2165  28 
         public Object getTree() { return tree; }
 2166   
     };
 2167   
 
 2168   
 
 2169   
     // $ANTLR start "describeQuery"
 2170   
     // com\\googlecode\\sparkleg\\Sparql.g:117:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2171   
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2172  28 
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2173  28 
         retval.start = input.LT(1);
 2174   
 
 2175   
 
 2176  28 
         Object root_0 = null;
 2177   
 
 2178  28 
         Token DESCRIBE49=null;
 2179  28 
         Token ASTERISK50=null;
 2180  28 
         List list_v=null;
 2181  28 
         SparqlParser.datasetClause_return datasetClause51 =null;
 2182   
 
 2183  28 
         SparqlParser.whereClause_return whereClause52 =null;
 2184   
 
 2185  28 
         SparqlParser.solutionModifier_return solutionModifier53 =null;
 2186   
 
 2187  28 
         RuleReturnScope v = null;
 2188  28 
         Object DESCRIBE49_tree=null;
 2189  28 
         Object ASTERISK50_tree=null;
 2190  28 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2191  28 
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2192  28 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2193  28 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2194  28 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2195  28 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2196   
         try {
 2197   
             // com\\googlecode\\sparkleg\\Sparql.g:118:5: ( DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2198   
             // com\\googlecode\\sparkleg\\Sparql.g:118:7: DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier
 2199   
             {
 2200  28 
             DESCRIBE49=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery637);
 2201  28 
             stream_DESCRIBE.add(DESCRIBE49);
 2202   
 
 2203   
 
 2204   
             // com\\googlecode\\sparkleg\\Sparql.g:118:16: ( (v+= varOrIRIref )+ | ASTERISK )
 2205  28 
             int alt16=2;
 2206  28 
             switch ( input.LA(1) ) {
 2207   
             case IRI_REF:
 2208   
             case PNAME_LN:
 2209   
             case PNAME_NS:
 2210   
             case VAR1:
 2211   
             case VAR2:
 2212   
                 {
 2213  28 
                 alt16=1;
 2214   
                 }
 2215  28 
                 break;
 2216   
             case ASTERISK:
 2217   
                 {
 2218  0 
                 alt16=2;
 2219   
                 }
 2220  0 
                 break;
 2221   
             default:
 2222  0 
                 NoViableAltException nvae =
 2223   
                     new NoViableAltException("", 16, 0, input);
 2224   
 
 2225  0 
                 throw nvae;
 2226   
 
 2227   
             }
 2228   
 
 2229  28 
             switch (alt16) {
 2230   
                 case 1 :
 2231   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2232   
                     {
 2233   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2234  28 
                     int cnt15=0;
 2235   
                     loop15:
 2236   
                     do {
 2237  70 
                         int alt15=2;
 2238  70 
                         switch ( input.LA(1) ) {
 2239   
                         case IRI_REF:
 2240   
                         case PNAME_LN:
 2241   
                         case PNAME_NS:
 2242   
                         case VAR1:
 2243   
                         case VAR2:
 2244   
                             {
 2245  42 
                             alt15=1;
 2246   
                             }
 2247   
                             break;
 2248   
 
 2249   
                         }
 2250   
 
 2251  70 
                         switch (alt15) {
 2252   
                             case 1 :
 2253   
                                 // com\\googlecode\\sparkleg\\Sparql.g:118:18: v+= varOrIRIref
 2254   
                                 {
 2255  42 
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery643);
 2256  42 
                                 v=varOrIRIref();
 2257   
 
 2258  42 
                                 state._fsp--;
 2259   
 
 2260  42 
                                 stream_varOrIRIref.add(v.getTree());
 2261  42 
                                 if (list_v==null) list_v=new ArrayList();
 2262  42 
                                 list_v.add(v.getTree());
 2263   
 
 2264   
 
 2265   
                                 }
 2266  42 
                                 break;
 2267   
 
 2268   
                             default :
 2269  28 
                                 if ( cnt15 >= 1 ) break loop15;
 2270  0 
                                 EarlyExitException eee =
 2271   
                                     new EarlyExitException(15, input);
 2272  0 
                                 throw eee;
 2273   
                         }
 2274  42 
                         cnt15++;
 2275  42 
                     } while (true);
 2276   
 
 2277   
 
 2278   
                     }
 2279  28 
                     break;
 2280   
                 case 2 :
 2281   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:37: ASTERISK
 2282   
                     {
 2283  0 
                     ASTERISK50=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery649);
 2284  0 
                     stream_ASTERISK.add(ASTERISK50);
 2285   
 
 2286   
 
 2287   
                     }
 2288   
                     break;
 2289   
 
 2290   
             }
 2291   
 
 2292   
 
 2293   
             // com\\googlecode\\sparkleg\\Sparql.g:118:47: ( datasetClause )*
 2294   
             loop17:
 2295   
             do {
 2296  28 
                 int alt17=2;
 2297  28 
                 switch ( input.LA(1) ) {
 2298   
                 case FROM:
 2299   
                     {
 2300  0 
                     alt17=1;
 2301   
                     }
 2302   
                     break;
 2303   
 
 2304   
                 }
 2305   
 
 2306  28 
                 switch (alt17) {
 2307   
                     case 1 :
 2308   
                         // com\\googlecode\\sparkleg\\Sparql.g:118:47: datasetClause
 2309   
                         {
 2310  0 
                         pushFollow(FOLLOW_datasetClause_in_describeQuery652);
 2311  0 
                         datasetClause51=datasetClause();
 2312   
 
 2313  0 
                         state._fsp--;
 2314   
 
 2315  0 
                         stream_datasetClause.add(datasetClause51.getTree());
 2316   
 
 2317   
                         }
 2318  0 
                         break;
 2319   
 
 2320   
                     default :
 2321  28 
                         break loop17;
 2322   
                 }
 2323  0 
             } while (true);
 2324   
 
 2325   
 
 2326   
             // com\\googlecode\\sparkleg\\Sparql.g:118:62: ( whereClause )?
 2327  28 
             int alt18=2;
 2328  28 
             switch ( input.LA(1) ) {
 2329   
                 case OPEN_CURLY_BRACE:
 2330   
                 case WHERE:
 2331   
                     {
 2332  22 
                     alt18=1;
 2333   
                     }
 2334   
                     break;
 2335   
             }
 2336   
 
 2337  28 
             switch (alt18) {
 2338   
                 case 1 :
 2339   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:62: whereClause
 2340   
                     {
 2341  22 
                     pushFollow(FOLLOW_whereClause_in_describeQuery655);
 2342  22 
                     whereClause52=whereClause();
 2343   
 
 2344  22 
                     state._fsp--;
 2345   
 
 2346  22 
                     stream_whereClause.add(whereClause52.getTree());
 2347   
 
 2348   
                     }
 2349   
                     break;
 2350   
 
 2351   
             }
 2352   
 
 2353   
 
 2354  28 
             pushFollow(FOLLOW_solutionModifier_in_describeQuery658);
 2355  28 
             solutionModifier53=solutionModifier();
 2356   
 
 2357  28 
             state._fsp--;
 2358   
 
 2359  28 
             stream_solutionModifier.add(solutionModifier53.getTree());
 2360   
 
 2361   
             // AST REWRITE
 2362   
             // elements: DESCRIBE, solutionModifier, v, ASTERISK, whereClause, datasetClause
 2363   
             // token labels:
 2364   
             // rule labels: retval
 2365   
             // token list labels:
 2366   
             // rule list labels: v
 2367   
             // wildcard labels:
 2368  28 
             retval.tree = root_0;
 2369  28 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2370  28 
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2371  28 
             root_0 = (Object)adaptor.nil();
 2372   
             // 118:92: -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2373   
             {
 2374   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:95: ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2375   
                 {
 2376  28 
                 Object root_1 = (Object)adaptor.nil();
 2377  28 
                 root_1 = (Object)adaptor.becomeRoot(
 2378   
                 stream_DESCRIBE.nextNode()
 2379   
                 , root_1);
 2380   
 
 2381   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:107: ( $v)*
 2382  70 
                 while ( stream_v.hasNext() ) {
 2383  42 
                     adaptor.addChild(root_1, stream_v.nextTree());
 2384   
 
 2385   
                 }
 2386  28 
                 stream_v.reset();
 2387   
 
 2388   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:110: ( ASTERISK )*
 2389  28 
                 while ( stream_ASTERISK.hasNext() ) {
 2390  0 
                     adaptor.addChild(root_1,
 2391   
                     stream_ASTERISK.nextNode()
 2392   
                     );
 2393   
 
 2394   
                 }
 2395  28 
                 stream_ASTERISK.reset();
 2396   
 
 2397   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:120: ( datasetClause )*
 2398  28 
                 while ( stream_datasetClause.hasNext() ) {
 2399  0 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2400   
 
 2401   
                 }
 2402  28 
                 stream_datasetClause.reset();
 2403   
 
 2404   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:135: ( whereClause )?
 2405  28 
                 if ( stream_whereClause.hasNext() ) {
 2406  22 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2407   
 
 2408   
                 }
 2409  28 
                 stream_whereClause.reset();
 2410   
 
 2411   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:148: ( solutionModifier )*
 2412  28 
                 while ( stream_solutionModifier.hasNext() ) {
 2413  0 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2414   
 
 2415   
                 }
 2416  28 
                 stream_solutionModifier.reset();
 2417   
 
 2418  28 
                 adaptor.addChild(root_0, root_1);
 2419   
                 }
 2420   
 
 2421   
             }
 2422   
 
 2423   
 
 2424  28 
             retval.tree = root_0;
 2425   
 
 2426   
             }
 2427   
 
 2428  28 
             retval.stop = input.LT(-1);
 2429   
 
 2430   
 
 2431  28 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2432  28 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2433   
 
 2434   
         }
 2435  0 
         catch (RecognitionException re) {
 2436  0 
             reportError(re);
 2437  0 
             recover(input,re);
 2438  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2439   
 
 2440   
         }
 2441   
 
 2442  0 
         finally {
 2443   
                 // do for sure before leaving
 2444  28 
         }
 2445  28 
         return retval;
 2446   
     }
 2447   
     // $ANTLR end "describeQuery"
 2448   
 
 2449   
 
 2450  120 
     public static class askQuery_return extends ParserRuleReturnScope {
 2451   
         Object tree;
 2452  120 
         public Object getTree() { return tree; }
 2453   
     };
 2454   
 
 2455   
 
 2456   
     // $ANTLR start "askQuery"
 2457   
     // com\\googlecode\\sparkleg\\Sparql.g:121:1: askQuery : ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) ;
 2458   
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2459  120 
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2460  120 
         retval.start = input.LT(1);
 2461   
 
 2462   
 
 2463  120 
         Object root_0 = null;
 2464   
 
 2465  120 
         Token ASK54=null;
 2466  120 
         SparqlParser.datasetClause_return datasetClause55 =null;
 2467   
 
 2468  120 
         SparqlParser.whereClause_return whereClause56 =null;
 2469   
 
 2470   
 
 2471  120 
         Object ASK54_tree=null;
 2472  120 
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2473  120 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2474  120 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2475   
         try {
 2476   
             // com\\googlecode\\sparkleg\\Sparql.g:122:5: ( ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) )
 2477   
             // com\\googlecode\\sparkleg\\Sparql.g:122:7: ASK ( datasetClause )* whereClause
 2478   
             {
 2479  120 
             ASK54=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery697);
 2480  120 
             stream_ASK.add(ASK54);
 2481   
 
 2482   
 
 2483   
             // com\\googlecode\\sparkleg\\Sparql.g:122:11: ( datasetClause )*
 2484   
             loop19:
 2485   
             do {
 2486  120 
                 int alt19=2;
 2487  120 
                 switch ( input.LA(1) ) {
 2488   
                 case FROM:
 2489   
                     {
 2490  0 
                     alt19=1;
 2491   
                     }
 2492   
                     break;
 2493   
 
 2494   
                 }
 2495   
 
 2496  120 
                 switch (alt19) {
 2497   
                     case 1 :
 2498   
                         // com\\googlecode\\sparkleg\\Sparql.g:122:11: datasetClause
 2499   
                         {
 2500  0 
                         pushFollow(FOLLOW_datasetClause_in_askQuery699);
 2501  0 
                         datasetClause55=datasetClause();
 2502   
 
 2503  0 
                         state._fsp--;
 2504   
 
 2505  0 
                         stream_datasetClause.add(datasetClause55.getTree());
 2506   
 
 2507   
                         }
 2508  0 
                         break;
 2509   
 
 2510   
                     default :
 2511  120 
                         break loop19;
 2512   
                 }
 2513  0 
             } while (true);
 2514   
 
 2515   
 
 2516  120 
             pushFollow(FOLLOW_whereClause_in_askQuery702);
 2517  120 
             whereClause56=whereClause();
 2518   
 
 2519  120 
             state._fsp--;
 2520   
 
 2521  120 
             stream_whereClause.add(whereClause56.getTree());
 2522   
 
 2523   
             // AST REWRITE
 2524   
             // elements: datasetClause, ASK, whereClause
 2525   
             // token labels:
 2526   
             // rule labels: retval
 2527   
             // token list labels:
 2528   
             // rule list labels:
 2529   
             // wildcard labels:
 2530  120 
             retval.tree = root_0;
 2531  120 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2532   
 
 2533  120 
             root_0 = (Object)adaptor.nil();
 2534   
             // 122:38: -> ^( ASK ( datasetClause )* whereClause )
 2535   
             {
 2536   
                 // com\\googlecode\\sparkleg\\Sparql.g:122:41: ^( ASK ( datasetClause )* whereClause )
 2537   
                 {
 2538  120 
                 Object root_1 = (Object)adaptor.nil();
 2539  120 
                 root_1 = (Object)adaptor.becomeRoot(
 2540   
                 stream_ASK.nextNode()
 2541   
                 , root_1);
 2542   
 
 2543   
                 // com\\googlecode\\sparkleg\\Sparql.g:122:47: ( datasetClause )*
 2544  120 
                 while ( stream_datasetClause.hasNext() ) {
 2545  0 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2546   
 
 2547   
                 }
 2548  120 
                 stream_datasetClause.reset();
 2549   
 
 2550  120 
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2551   
 
 2552  120 
                 adaptor.addChild(root_0, root_1);
 2553   
                 }
 2554   
 
 2555   
             }
 2556   
 
 2557   
 
 2558  120 
             retval.tree = root_0;
 2559   
 
 2560   
             }
 2561   
 
 2562  120 
             retval.stop = input.LT(-1);
 2563   
 
 2564   
 
 2565  120 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2566  120 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2567   
 
 2568   
         }
 2569  0 
         catch (RecognitionException re) {
 2570  0 
             reportError(re);
 2571  0 
             recover(input,re);
 2572  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2573   
 
 2574   
         }
 2575   
 
 2576  0 
         finally {
 2577   
                 // do for sure before leaving
 2578  120 
         }
 2579  120 
         return retval;
 2580   
     }
 2581   
     // $ANTLR end "askQuery"
 2582   
 
 2583   
 
 2584  160 
     public static class datasetClause_return extends ParserRuleReturnScope {
 2585   
         Object tree;
 2586  160 
         public Object getTree() { return tree; }
 2587   
     };
 2588   
 
 2589   
 
 2590   
     // $ANTLR start "datasetClause"
 2591   
     // com\\googlecode\\sparkleg\\Sparql.g:125:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2592   
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2593  160 
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2594  160 
         retval.start = input.LT(1);
 2595   
 
 2596   
 
 2597  160 
         Object root_0 = null;
 2598   
 
 2599  160 
         Token FROM57=null;
 2600  160 
         Token NAMED58=null;
 2601  160 
         SparqlParser.iriRef_return iriRef59 =null;
 2602   
 
 2603   
 
 2604  160 
         Object FROM57_tree=null;
 2605  160 
         Object NAMED58_tree=null;
 2606  160 
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2607  160 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2608  160 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2609   
         try {
 2610   
             // com\\googlecode\\sparkleg\\Sparql.g:126:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2611   
             // com\\googlecode\\sparkleg\\Sparql.g:126:7: FROM ( NAMED )? iriRef
 2612   
             {
 2613  160 
             FROM57=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause730);
 2614  160 
             stream_FROM.add(FROM57);
 2615   
 
 2616   
 
 2617   
             // com\\googlecode\\sparkleg\\Sparql.g:126:12: ( NAMED )?
 2618  160 
             int alt20=2;
 2619  160 
             switch ( input.LA(1) ) {
 2620   
                 case NAMED:
 2621   
                     {
 2622  102 
                     alt20=1;
 2623   
                     }
 2624   
                     break;
 2625   
             }
 2626   
 
 2627  160 
             switch (alt20) {
 2628   
                 case 1 :
 2629   
                     // com\\googlecode\\sparkleg\\Sparql.g:126:12: NAMED
 2630   
                     {
 2631  102 
                     NAMED58=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause732);
 2632  102 
                     stream_NAMED.add(NAMED58);
 2633   
 
 2634   
 
 2635   
                     }
 2636   
                     break;
 2637   
 
 2638   
             }
 2639   
 
 2640   
 
 2641  160 
             pushFollow(FOLLOW_iriRef_in_datasetClause735);
 2642  160 
             iriRef59=iriRef();
 2643   
 
 2644  160 
             state._fsp--;
 2645   
 
 2646  160 
             stream_iriRef.add(iriRef59.getTree());
 2647   
 
 2648   
             // AST REWRITE
 2649   
             // elements: NAMED, iriRef, FROM
 2650   
             // token labels:
 2651   
             // rule labels: retval
 2652   
             // token list labels:
 2653   
             // rule list labels:
 2654   
             // wildcard labels:
 2655  160 
             retval.tree = root_0;
 2656  160 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2657   
 
 2658  160 
             root_0 = (Object)adaptor.nil();
 2659   
             // 126:26: -> ^( FROM ( NAMED )? iriRef )
 2660   
             {
 2661   
                 // com\\googlecode\\sparkleg\\Sparql.g:126:29: ^( FROM ( NAMED )? iriRef )
 2662   
                 {
 2663  160 
                 Object root_1 = (Object)adaptor.nil();
 2664  160 
                 root_1 = (Object)adaptor.becomeRoot(
 2665   
                 stream_FROM.nextNode()
 2666   
                 , root_1);
 2667   
 
 2668   
                 // com\\googlecode\\sparkleg\\Sparql.g:126:36: ( NAMED )?
 2669  160 
                 if ( stream_NAMED.hasNext() ) {
 2670  102 
                     adaptor.addChild(root_1,
 2671   
                     stream_NAMED.nextNode()
 2672   
                     );
 2673   
 
 2674   
                 }
 2675  160 
                 stream_NAMED.reset();
 2676   
 
 2677  160 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2678   
 
 2679  160 
                 adaptor.addChild(root_0, root_1);
 2680   
                 }
 2681   
 
 2682   
             }
 2683   
 
 2684   
 
 2685  160 
             retval.tree = root_0;
 2686   
 
 2687   
             }
 2688   
 
 2689  160 
             retval.stop = input.LT(-1);
 2690   
 
 2691   
 
 2692  160 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2693  160 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2694   
 
 2695   
         }
 2696  0 
         catch (RecognitionException re) {
 2697  0 
             reportError(re);
 2698  0 
             recover(input,re);
 2699  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2700   
 
 2701   
         }
 2702   
 
 2703  0 
         finally {
 2704   
                 // do for sure before leaving
 2705  160 
         }
 2706  160 
         return retval;
 2707   
     }
 2708   
     // $ANTLR end "datasetClause"
 2709   
 
 2710   
 
 2711  1856 
     public static class whereClause_return extends ParserRuleReturnScope {
 2712   
         Object tree;
 2713  1856 
         public Object getTree() { return tree; }
 2714   
     };
 2715   
 
 2716   
 
 2717   
     // $ANTLR start "whereClause"
 2718   
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2719   
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2720  1856 
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2721  1856 
         retval.start = input.LT(1);
 2722   
 
 2723   
 
 2724  1856 
         Object root_0 = null;
 2725   
 
 2726  1856 
         Token WHERE60=null;
 2727  1856 
         SparqlParser.groupGraphPattern_return groupGraphPattern61 =null;
 2728   
 
 2729   
 
 2730  1856 
         Object WHERE60_tree=null;
 2731  1856 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2732  1856 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2733   
         try {
 2734   
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2735   
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )? groupGraphPattern
 2736   
             {
 2737   
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )?
 2738  1856 
             int alt21=2;
 2739  1856 
             switch ( input.LA(1) ) {
 2740   
                 case WHERE:
 2741   
                     {
 2742  1356 
                     alt21=1;
 2743   
                     }
 2744   
                     break;
 2745   
             }
 2746   
 
 2747  1856 
             switch (alt21) {
 2748   
                 case 1 :
 2749   
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: WHERE
 2750   
                     {
 2751  1356 
                     WHERE60=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause763);
 2752  1356 
                     stream_WHERE.add(WHERE60);
 2753   
 
 2754   
 
 2755   
                     }
 2756   
                     break;
 2757   
 
 2758   
             }
 2759   
 
 2760   
 
 2761  1856 
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause766);
 2762  1856 
             groupGraphPattern61=groupGraphPattern();
 2763   
 
 2764  1856 
             state._fsp--;
 2765   
 
 2766  1856 
             stream_groupGraphPattern.add(groupGraphPattern61.getTree());
 2767   
 
 2768   
             // AST REWRITE
 2769   
             // elements: groupGraphPattern
 2770   
             // token labels:
 2771   
             // rule labels: retval
 2772   
             // token list labels:
 2773   
             // rule list labels:
 2774   
             // wildcard labels:
 2775  1856 
             retval.tree = root_0;
 2776  1856 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2777   
 
 2778  1856 
             root_0 = (Object)adaptor.nil();
 2779   
             // 130:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2780   
             {
 2781   
                 // com\\googlecode\\sparkleg\\Sparql.g:130:35: ^( WHERE_CLAUSE groupGraphPattern )
 2782   
                 {
 2783  1856 
                 Object root_1 = (Object)adaptor.nil();
 2784  1856 
                 root_1 = (Object)adaptor.becomeRoot(
 2785   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2786   
                 , root_1);
 2787   
 
 2788  1856 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2789   
 
 2790  1856 
                 adaptor.addChild(root_0, root_1);
 2791   
                 }
 2792   
 
 2793   
             }
 2794   
 
 2795   
 
 2796  1856 
             retval.tree = root_0;
 2797   
 
 2798   
             }
 2799   
 
 2800  1856 
             retval.stop = input.LT(-1);
 2801   
 
 2802   
 
 2803  1856 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2804  1856 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2805   
 
 2806   
         }
 2807  0 
         catch (RecognitionException re) {
 2808  0 
             reportError(re);
 2809  0 
             recover(input,re);
 2810  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2811   
 
 2812   
         }
 2813   
 
 2814  0 
         finally {
 2815   
                 // do for sure before leaving
 2816  1856 
         }
 2817  1856 
         return retval;
 2818   
     }
 2819   
     // $ANTLR end "whereClause"
 2820   
 
 2821   
 
 2822  1758 
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2823   
         Object tree;
 2824  1758 
         public Object getTree() { return tree; }
 2825   
     };
 2826   
 
 2827   
 
 2828   
     // $ANTLR start "solutionModifier"
 2829   
     // com\\googlecode\\sparkleg\\Sparql.g:133:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2830   
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2831  1758 
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2832  1758 
         retval.start = input.LT(1);
 2833   
 
 2834   
 
 2835  1758 
         Object root_0 = null;
 2836   
 
 2837  1758 
         SparqlParser.groupClause_return groupClause62 =null;
 2838   
 
 2839  1758 
         SparqlParser.havingClause_return havingClause63 =null;
 2840   
 
 2841  1758 
         SparqlParser.orderClause_return orderClause64 =null;
 2842   
 
 2843  1758 
         SparqlParser.limitOffsetClauses_return limitOffsetClauses65 =null;
 2844   
 
 2845   
 
 2846  1758 
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2847  1758 
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2848  1758 
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2849  1758 
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2850   
         try {
 2851   
             // com\\googlecode\\sparkleg\\Sparql.g:134:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2852   
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2853   
             {
 2854   
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )?
 2855  1758 
             int alt22=2;
 2856  1758 
             switch ( input.LA(1) ) {
 2857   
                 case GROUP:
 2858   
                     {
 2859  66 
                     alt22=1;
 2860   
                     }
 2861   
                     break;
 2862   
             }
 2863   
 
 2864  1758 
             switch (alt22) {
 2865   
                 case 1 :
 2866   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:7: groupClause
 2867   
                     {
 2868  66 
                     pushFollow(FOLLOW_groupClause_in_solutionModifier791);
 2869  66 
                     groupClause62=groupClause();
 2870   
 
 2871  66 
                     state._fsp--;
 2872   
 
 2873  66 
                     stream_groupClause.add(groupClause62.getTree());
 2874   
 
 2875   
                     }
 2876   
                     break;
 2877   
 
 2878   
             }
 2879   
 
 2880   
 
 2881   
             // com\\googlecode\\sparkleg\\Sparql.g:134:20: ( havingClause )?
 2882  1758 
             int alt23=2;
 2883  1758 
             switch ( input.LA(1) ) {
 2884   
                 case HAVING:
 2885   
                     {
 2886  16 
                     alt23=1;
 2887   
                     }
 2888   
                     break;
 2889   
             }
 2890   
 
 2891  1758 
             switch (alt23) {
 2892   
                 case 1 :
 2893   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:20: havingClause
 2894   
                     {
 2895  16 
                     pushFollow(FOLLOW_havingClause_in_solutionModifier794);
 2896  16 
                     havingClause63=havingClause();
 2897   
 
 2898  16 
                     state._fsp--;
 2899   
 
 2900  16 
                     stream_havingClause.add(havingClause63.getTree());
 2901   
 
 2902   
                     }
 2903   
                     break;
 2904   
 
 2905   
             }
 2906   
 
 2907   
 
 2908   
             // com\\googlecode\\sparkleg\\Sparql.g:134:34: ( orderClause )?
 2909  1758 
             int alt24=2;
 2910  1758 
             switch ( input.LA(1) ) {
 2911   
                 case ORDER:
 2912   
                     {
 2913  134 
                     alt24=1;
 2914   
                     }
 2915   
                     break;
 2916   
             }
 2917   
 
 2918  1758 
             switch (alt24) {
 2919   
                 case 1 :
 2920   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:34: orderClause
 2921   
                     {
 2922  134 
                     pushFollow(FOLLOW_orderClause_in_solutionModifier797);
 2923  134 
                     orderClause64=orderClause();
 2924   
 
 2925  134 
                     state._fsp--;
 2926   
 
 2927  134 
                     stream_orderClause.add(orderClause64.getTree());
 2928   
 
 2929   
                     }
 2930   
                     break;
 2931   
 
 2932   
             }
 2933   
 
 2934   
 
 2935   
             // com\\googlecode\\sparkleg\\Sparql.g:134:47: ( limitOffsetClauses )?
 2936  1758 
             int alt25=2;
 2937  1758 
             switch ( input.LA(1) ) {
 2938   
                 case LIMIT:
 2939   
                 case OFFSET:
 2940   
                     {
 2941  58 
                     alt25=1;
 2942   
                     }
 2943   
                     break;
 2944   
             }
 2945   
 
 2946  1758 
             switch (alt25) {
 2947   
                 case 1 :
 2948   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:47: limitOffsetClauses
 2949   
                     {
 2950  58 
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier800);
 2951  58 
                     limitOffsetClauses65=limitOffsetClauses();
 2952   
 
 2953  58 
                     state._fsp--;
 2954   
 
 2955  58 
                     stream_limitOffsetClauses.add(limitOffsetClauses65.getTree());
 2956   
 
 2957   
                     }
 2958   
                     break;
 2959   
 
 2960   
             }
 2961   
 
 2962   
 
 2963   
             // AST REWRITE
 2964   
             // elements: havingClause, limitOffsetClauses, orderClause, groupClause
 2965   
             // token labels:
 2966   
             // rule labels: retval
 2967   
             // token list labels:
 2968   
             // rule list labels:
 2969   
             // wildcard labels:
 2970  1758 
             retval.tree = root_0;
 2971  1758 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2972   
 
 2973  1758 
             root_0 = (Object)adaptor.nil();
 2974   
             // 134:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 2975   
             {
 2976   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:70: ( groupClause )*
 2977  1824 
                 while ( stream_groupClause.hasNext() ) {
 2978  66 
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 2979   
 
 2980   
                 }
 2981  1758 
                 stream_groupClause.reset();
 2982   
 
 2983   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:83: ( havingClause )*
 2984  1774 
                 while ( stream_havingClause.hasNext() ) {
 2985  16 
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 2986   
 
 2987   
                 }
 2988  1758 
                 stream_havingClause.reset();
 2989   
 
 2990   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:97: ( orderClause )*
 2991  1892 
                 while ( stream_orderClause.hasNext() ) {
 2992  134 
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 2993   
 
 2994   
                 }
 2995  1758 
                 stream_orderClause.reset();
 2996   
 
 2997   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:110: ( limitOffsetClauses )*
 2998  1816 
                 while ( stream_limitOffsetClauses.hasNext() ) {
 2999  58 
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3000   
 
 3001   
                 }
 3002  1758 
                 stream_limitOffsetClauses.reset();
 3003   
 
 3004   
             }
 3005   
 
 3006   
 
 3007  1758 
             retval.tree = root_0;
 3008   
 
 3009   
             }
 3010   
 
 3011  1758 
             retval.stop = input.LT(-1);
 3012   
 
 3013   
 
 3014  1758 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3015  1758 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3016   
 
 3017   
         }
 3018  0 
         catch (RecognitionException re) {
 3019  0 
             reportError(re);
 3020  0 
             recover(input,re);
 3021  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3022   
 
 3023   
         }
 3024   
 
 3025  0 
         finally {
 3026   
                 // do for sure before leaving
 3027  1758 
         }
 3028  1758 
         return retval;
 3029   
     }
 3030   
     // $ANTLR end "solutionModifier"
 3031   
 
 3032   
 
 3033  66 
     public static class groupClause_return extends ParserRuleReturnScope {
 3034   
         Object tree;
 3035  66 
         public Object getTree() { return tree; }
 3036   
     };
 3037   
 
 3038   
 
 3039   
     // $ANTLR start "groupClause"
 3040   
     // com\\googlecode\\sparkleg\\Sparql.g:137:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3041   
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3042  66 
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3043  66 
         retval.start = input.LT(1);
 3044   
 
 3045   
 
 3046  66 
         Object root_0 = null;
 3047   
 
 3048  66 
         Token GROUP66=null;
 3049  66 
         Token BY67=null;
 3050  66 
         SparqlParser.groupCondition_return groupCondition68 =null;
 3051   
 
 3052   
 
 3053  66 
         Object GROUP66_tree=null;
 3054  66 
         Object BY67_tree=null;
 3055  66 
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3056  66 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3057  66 
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3058   
         try {
 3059   
             // com\\googlecode\\sparkleg\\Sparql.g:138:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3060   
             // com\\googlecode\\sparkleg\\Sparql.g:138:7: GROUP BY ( groupCondition )+
 3061   
             {
 3062  66 
             GROUP66=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause832);
 3063  66 
             stream_GROUP.add(GROUP66);
 3064   
 
 3065   
 
 3066  66 
             BY67=(Token)match(input,BY,FOLLOW_BY_in_groupClause834);
 3067  66 
             stream_BY.add(BY67);
 3068   
 
 3069   
 
 3070   
             // com\\googlecode\\sparkleg\\Sparql.g:138:16: ( groupCondition )+
 3071  66 
             int cnt26=0;
 3072   
             loop26:
 3073   
             do {
 3074  136 
                 int alt26=2;
 3075  136 
                 switch ( input.LA(1) ) {
 3076   
                 case ABS:
 3077   
                 case BNODE:
 3078   
                 case BOUND:
 3079   
                 case CEIL:
 3080   
                 case COALESCE:
 3081   
                 case CONCAT:
 3082   
                 case CONTAINS:
 3083   
                 case DATATYPE:
 3084   
                 case DAY:
 3085   
                 case ENCODE_FOR_URI:
 3086   
                 case EXISTS:
 3087   
                 case FLOOR:
 3088   
                 case HOURS:
 3089   
                 case IF:
 3090   
                 case IRI:
 3091   
                 case IRI_REF:
 3092   
                 case ISBLANK:
 3093   
                 case ISIRI:
 3094   
                 case ISLITERAL:
 3095   
                 case ISNUMERIC:
 3096   
                 case ISURI:
 3097   
                 case LANG:
 3098   
                 case LANGMATCHES:
 3099   
                 case LCASE:
 3100   
                 case MD5:
 3101   
                 case MINUTES:
 3102   
                 case MONTH:
 3103   
                 case NOT:
 3104   
                 case NOW:
 3105   
                 case OPEN_BRACE:
 3106   
                 case PNAME_LN:
 3107   
                 case PNAME_NS:
 3108   
                 case RAND:
 3109   
                 case REGEX:
 3110   
                 case REPLACE:
 3111   
                 case ROUND:
 3112   
                 case SAMETERM:
 3113   
                 case SECONDS:
 3114   
                 case SHA1:
 3115   
                 case SHA224:
 3116   
                 case SHA256:
 3117   
                 case SHA384:
 3118   
                 case SHA512:
 3119   
                 case STR:
 3120   
                 case STRAFTER:
 3121   
                 case STRBEFORE:
 3122   
                 case STRDT:
 3123   
                 case STRENDS:
 3124   
                 case STRLANG:
 3125   
                 case STRLEN:
 3126   
                 case STRSTARTS:
 3127   
                 case SUBSTR:
 3128   
                 case TIMEZONE:
 3129   
                 case TZ:
 3130   
                 case UCASE:
 3131   
                 case URI:
 3132   
                 case VAR1:
 3133   
                 case VAR2:
 3134   
                 case YEAR:
 3135   
                     {
 3136  70 
                     alt26=1;
 3137   
                     }
 3138   
                     break;
 3139   
 
 3140   
                 }
 3141   
 
 3142  136 
                 switch (alt26) {
 3143   
                     case 1 :
 3144   
                         // com\\googlecode\\sparkleg\\Sparql.g:138:16: groupCondition
 3145   
                         {
 3146  70 
                         pushFollow(FOLLOW_groupCondition_in_groupClause836);
 3147  70 
                         groupCondition68=groupCondition();
 3148   
 
 3149  70 
                         state._fsp--;
 3150   
 
 3151  70 
                         stream_groupCondition.add(groupCondition68.getTree());
 3152   
 
 3153   
                         }
 3154  70 
                         break;
 3155   
 
 3156   
                     default :
 3157  66 
                         if ( cnt26 >= 1 ) break loop26;
 3158  0 
                         EarlyExitException eee =
 3159   
                             new EarlyExitException(26, input);
 3160  0 
                         throw eee;
 3161   
                 }
 3162  70 
                 cnt26++;
 3163  70 
             } while (true);
 3164   
 
 3165   
 
 3166   
             // AST REWRITE
 3167   
             // elements: groupCondition
 3168   
             // token labels:
 3169   
             // rule labels: retval
 3170   
             // token list labels:
 3171   
             // rule list labels:
 3172   
             // wildcard labels:
 3173  66 
             retval.tree = root_0;
 3174  66 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3175   
 
 3176  66 
             root_0 = (Object)adaptor.nil();
 3177   
             // 138:32: -> ^( GROUP_BY ( groupCondition )+ )
 3178   
             {
 3179   
                 // com\\googlecode\\sparkleg\\Sparql.g:138:35: ^( GROUP_BY ( groupCondition )+ )
 3180   
                 {
 3181  66 
                 Object root_1 = (Object)adaptor.nil();
 3182  66 
                 root_1 = (Object)adaptor.becomeRoot(
 3183   
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3184   
                 , root_1);
 3185   
 
 3186  66 
                 if ( !(stream_groupCondition.hasNext()) ) {
 3187  0 
                     throw new RewriteEarlyExitException();
 3188   
                 }
 3189  136 
                 while ( stream_groupCondition.hasNext() ) {
 3190  70 
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3191   
 
 3192   
                 }
 3193  66 
                 stream_groupCondition.reset();
 3194   
 
 3195  66 
                 adaptor.addChild(root_0, root_1);
 3196   
                 }
 3197   
 
 3198   
             }
 3199   
 
 3200   
 
 3201  66 
             retval.tree = root_0;
 3202   
 
 3203   
             }
 3204   
 
 3205  66 
             retval.stop = input.LT(-1);
 3206   
 
 3207   
 
 3208  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3209  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3210   
 
 3211   
         }
 3212  0 
         catch (RecognitionException re) {
 3213  0 
             reportError(re);
 3214  0 
             recover(input,re);
 3215  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3216   
 
 3217   
         }
 3218   
 
 3219  0 
         finally {
 3220   
                 // do for sure before leaving
 3221  66 
         }
 3222  66 
         return retval;
 3223   
     }
 3224   
     // $ANTLR end "groupClause"
 3225   
 
 3226   
 
 3227  70 
     public static class groupCondition_return extends ParserRuleReturnScope {
 3228   
         Object tree;
 3229  70 
         public Object getTree() { return tree; }
 3230   
     };
 3231   
 
 3232   
 
 3233   
     // $ANTLR start "groupCondition"
 3234   
     // com\\googlecode\\sparkleg\\Sparql.g:141:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( ^( AS var ) )? ) | var -> ^( GROUP_CONDITION var ) );
 3235   
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3236  70 
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3237  70 
         retval.start = input.LT(1);
 3238   
 
 3239   
 
 3240  70 
         Object root_0 = null;
 3241   
 
 3242  70 
         Token OPEN_BRACE71=null;
 3243  70 
         Token AS73=null;
 3244  70 
         Token CLOSE_BRACE75=null;
 3245  70 
         SparqlParser.builtInCall_return builtInCall69 =null;
 3246   
 
 3247  70 
         SparqlParser.functionCall_return functionCall70 =null;
 3248   
 
 3249  70 
         SparqlParser.expression_return expression72 =null;
 3250   
 
 3251  70 
         SparqlParser.var_return var74 =null;
 3252   
 
 3253  70 
         SparqlParser.var_return var76 =null;
 3254   
 
 3255   
 
 3256  70 
         Object OPEN_BRACE71_tree=null;
 3257  70 
         Object AS73_tree=null;
 3258  70 
         Object CLOSE_BRACE75_tree=null;
 3259  70 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3260  70 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 3261  70 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 3262  70 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3263  70 
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3264  70 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3265  70 
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3266   
         try {
 3267   
             // com\\googlecode\\sparkleg\\Sparql.g:142:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( ^( AS var ) )? ) | var -> ^( GROUP_CONDITION var ) )
 3268  70 
             int alt28=4;
 3269  70 
             switch ( input.LA(1) ) {
 3270   
             case ABS:
 3271   
             case BNODE:
 3272   
             case BOUND:
 3273   
             case CEIL:
 3274   
             case COALESCE:
 3275   
             case CONCAT:
 3276   
             case CONTAINS:
 3277   
             case DATATYPE:
 3278   
             case DAY:
 3279   
             case ENCODE_FOR_URI:
 3280   
             case EXISTS:
 3281   
             case FLOOR:
 3282   
             case HOURS:
 3283   
             case IF:
 3284   
             case IRI:
 3285   
             case ISBLANK:
 3286   
             case ISIRI:
 3287   
             case ISLITERAL:
 3288   
             case ISNUMERIC:
 3289   
             case ISURI:
 3290   
             case LANG:
 3291   
             case LANGMATCHES:
 3292   
             case LCASE:
 3293   
             case MD5:
 3294   
             case MINUTES:
 3295   
             case MONTH:
 3296   
             case NOT:
 3297   
             case NOW:
 3298   
             case RAND:
 3299   
             case REGEX:
 3300   
             case REPLACE:
 3301   
             case ROUND:
 3302   
             case SAMETERM:
 3303   
             case SECONDS:
 3304   
             case SHA1:
 3305   
             case SHA224:
 3306   
             case SHA256:
 3307   
             case SHA384:
 3308   
             case SHA512:
 3309   
             case STR:
 3310   
             case STRAFTER:
 3311   
             case STRBEFORE:
 3312   
             case STRDT:
 3313   
             case STRENDS:
 3314   
             case STRLANG:
 3315   
             case STRLEN:
 3316   
             case STRSTARTS:
 3317   
             case SUBSTR:
 3318   
             case TIMEZONE:
 3319   
             case TZ:
 3320   
             case UCASE:
 3321   
             case URI:
 3322   
             case YEAR:
 3323   
                 {
 3324  0 
                 alt28=1;
 3325   
                 }
 3326  0 
                 break;
 3327   
             case IRI_REF:
 3328   
             case PNAME_LN:
 3329   
             case PNAME_NS:
 3330   
                 {
 3331  0 
                 alt28=2;
 3332   
                 }
 3333  0 
                 break;
 3334   
             case OPEN_BRACE:
 3335   
                 {
 3336  12 
                 alt28=3;
 3337   
                 }
 3338  12 
                 break;
 3339   
             case VAR1:
 3340   
             case VAR2:
 3341   
                 {
 3342  58 
                 alt28=4;
 3343   
                 }
 3344  58 
                 break;
 3345   
             default:
 3346  0 
                 NoViableAltException nvae =
 3347   
                     new NoViableAltException("", 28, 0, input);
 3348   
 
 3349  0 
                 throw nvae;
 3350   
 
 3351   
             }
 3352   
 
 3353  70 
             switch (alt28) {
 3354   
                 case 1 :
 3355   
                     // com\\googlecode\\sparkleg\\Sparql.g:142:7: builtInCall
 3356   
                     {
 3357  0 
                     pushFollow(FOLLOW_builtInCall_in_groupCondition870);
 3358  0 
                     builtInCall69=builtInCall();
 3359   
 
 3360  0 
                     state._fsp--;
 3361   
 
 3362  0 
                     stream_builtInCall.add(builtInCall69.getTree());
 3363   
 
 3364   
                     // AST REWRITE
 3365   
                     // elements: builtInCall
 3366   
                     // token labels:
 3367   
                     // rule labels: retval
 3368   
                     // token list labels:
 3369   
                     // rule list labels:
 3370   
                     // wildcard labels:
 3371  0 
                     retval.tree = root_0;
 3372  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3373   
 
 3374  0 
                     root_0 = (Object)adaptor.nil();
 3375   
                     // 142:19: -> ^( GROUP_CONDITION builtInCall )
 3376   
                     {
 3377   
                         // com\\googlecode\\sparkleg\\Sparql.g:142:22: ^( GROUP_CONDITION builtInCall )
 3378   
                         {
 3379  0 
                         Object root_1 = (Object)adaptor.nil();
 3380  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3381   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3382   
                         , root_1);
 3383   
 
 3384  0 
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3385   
 
 3386  0 
                         adaptor.addChild(root_0, root_1);
 3387   
                         }
 3388   
 
 3389   
                     }
 3390   
 
 3391   
 
 3392  0 
                     retval.tree = root_0;
 3393   
 
 3394   
                     }
 3395  0 
                     break;
 3396   
                 case 2 :
 3397   
                     // com\\googlecode\\sparkleg\\Sparql.g:143:7: functionCall
 3398   
                     {
 3399  0 
                     pushFollow(FOLLOW_functionCall_in_groupCondition886);
 3400  0 
                     functionCall70=functionCall();
 3401   
 
 3402  0 
                     state._fsp--;
 3403   
 
 3404  0 
                     stream_functionCall.add(functionCall70.getTree());
 3405   
 
 3406   
                     // AST REWRITE
 3407   
                     // elements: functionCall
 3408   
                     // token labels:
 3409   
                     // rule labels: retval
 3410   
                     // token list labels:
 3411   
                     // rule list labels:
 3412   
                     // wildcard labels:
 3413  0 
                     retval.tree = root_0;
 3414  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3415   
 
 3416  0 
                     root_0 = (Object)adaptor.nil();
 3417   
                     // 143:20: -> ^( GROUP_CONDITION functionCall )
 3418   
                     {
 3419   
                         // com\\googlecode\\sparkleg\\Sparql.g:143:23: ^( GROUP_CONDITION functionCall )
 3420   
                         {
 3421  0 
                         Object root_1 = (Object)adaptor.nil();
 3422  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3423   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3424   
                         , root_1);
 3425   
 
 3426  0 
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3427   
 
 3428  0 
                         adaptor.addChild(root_0, root_1);
 3429   
                         }
 3430   
 
 3431   
                     }
 3432   
 
 3433   
 
 3434  0 
                     retval.tree = root_0;
 3435   
 
 3436   
                     }
 3437  0 
                     break;
 3438   
                 case 3 :
 3439   
                     // com\\googlecode\\sparkleg\\Sparql.g:144:7: OPEN_BRACE expression ( AS var )? CLOSE_BRACE
 3440   
                     {
 3441  12 
                     OPEN_BRACE71=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_groupCondition902);
 3442  12 
                     stream_OPEN_BRACE.add(OPEN_BRACE71);
 3443   
 
 3444   
 
 3445  12 
                     pushFollow(FOLLOW_expression_in_groupCondition904);
 3446  12 
                     expression72=expression();
 3447   
 
 3448  12 
                     state._fsp--;
 3449   
 
 3450  12 
                     stream_expression.add(expression72.getTree());
 3451   
 
 3452   
                     // com\\googlecode\\sparkleg\\Sparql.g:144:29: ( AS var )?
 3453  12 
                     int alt27=2;
 3454  12 
                     switch ( input.LA(1) ) {
 3455   
                         case AS:
 3456   
                             {
 3457  4 
                             alt27=1;
 3458   
                             }
 3459   
                             break;
 3460   
                     }
 3461   
 
 3462  12 
                     switch (alt27) {
 3463   
                         case 1 :
 3464   
                             // com\\googlecode\\sparkleg\\Sparql.g:144:30: AS var
 3465   
                             {
 3466  4 
                             AS73=(Token)match(input,AS,FOLLOW_AS_in_groupCondition907);
 3467  4 
                             stream_AS.add(AS73);
 3468   
 
 3469   
 
 3470  4 
                             pushFollow(FOLLOW_var_in_groupCondition909);
 3471  4 
                             var74=var();
 3472   
 
 3473  4 
                             state._fsp--;
 3474   
 
 3475  4 
                             stream_var.add(var74.getTree());
 3476   
 
 3477   
                             }
 3478   
                             break;
 3479   
 
 3480   
                     }
 3481   
 
 3482   
 
 3483  12 
                     CLOSE_BRACE75=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_groupCondition913);
 3484  12 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE75);
 3485   
 
 3486   
 
 3487   
                     // AST REWRITE
 3488   
                     // elements: expression, AS, var
 3489   
                     // token labels:
 3490   
                     // rule labels: retval
 3491   
                     // token list labels:
 3492   
                     // rule list labels:
 3493   
                     // wildcard labels:
 3494  12 
                     retval.tree = root_0;
 3495  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3496   
 
 3497  12 
                     root_0 = (Object)adaptor.nil();
 3498   
                     // 144:51: -> ^( GROUP_CONDITION expression ( ^( AS var ) )? )
 3499   
                     {
 3500   
                         // com\\googlecode\\sparkleg\\Sparql.g:144:54: ^( GROUP_CONDITION expression ( ^( AS var ) )? )
 3501   
                         {
 3502  12 
                         Object root_1 = (Object)adaptor.nil();
 3503  12 
                         root_1 = (Object)adaptor.becomeRoot(
 3504   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3505   
                         , root_1);
 3506   
 
 3507  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3508   
 
 3509   
                         // com\\googlecode\\sparkleg\\Sparql.g:144:83: ( ^( AS var ) )?
 3510  12 
                         if ( stream_AS.hasNext()||stream_var.hasNext() ) {
 3511   
                             // com\\googlecode\\sparkleg\\Sparql.g:144:83: ^( AS var )
 3512   
                             {
 3513  4 
                             Object root_2 = (Object)adaptor.nil();
 3514  4 
                             root_2 = (Object)adaptor.becomeRoot(
 3515   
                             stream_AS.nextNode()
 3516   
                             , root_2);
 3517   
 
 3518  4 
                             adaptor.addChild(root_2, stream_var.nextTree());
 3519   
 
 3520  4 
                             adaptor.addChild(root_1, root_2);
 3521   
                             }
 3522   
 
 3523   
                         }
 3524  12 
                         stream_AS.reset();
 3525  12 
                         stream_var.reset();
 3526   
 
 3527  12 
                         adaptor.addChild(root_0, root_1);
 3528   
                         }
 3529   
 
 3530   
                     }
 3531   
 
 3532   
 
 3533  12 
                     retval.tree = root_0;
 3534   
 
 3535   
                     }
 3536  12 
                     break;
 3537   
                 case 4 :
 3538   
                     // com\\googlecode\\sparkleg\\Sparql.g:145:7: var
 3539   
                     {
 3540  58 
                     pushFollow(FOLLOW_var_in_groupCondition937);
 3541  58 
                     var76=var();
 3542   
 
 3543  58 
                     state._fsp--;
 3544   
 
 3545  58 
                     stream_var.add(var76.getTree());
 3546   
 
 3547   
                     // AST REWRITE
 3548   
                     // elements: var
 3549   
                     // token labels:
 3550   
                     // rule labels: retval
 3551   
                     // token list labels:
 3552   
                     // rule list labels:
 3553   
                     // wildcard labels:
 3554  58 
                     retval.tree = root_0;
 3555  58 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3556   
 
 3557  58 
                     root_0 = (Object)adaptor.nil();
 3558   
                     // 145:11: -> ^( GROUP_CONDITION var )
 3559   
                     {
 3560   
                         // com\\googlecode\\sparkleg\\Sparql.g:145:14: ^( GROUP_CONDITION var )
 3561   
                         {
 3562  58 
                         Object root_1 = (Object)adaptor.nil();
 3563  58 
                         root_1 = (Object)adaptor.becomeRoot(
 3564   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3565   
                         , root_1);
 3566   
 
 3567  58 
                         adaptor.addChild(root_1, stream_var.nextTree());
 3568   
 
 3569  58 
                         adaptor.addChild(root_0, root_1);
 3570   
                         }
 3571   
 
 3572   
                     }
 3573   
 
 3574   
 
 3575  58 
                     retval.tree = root_0;
 3576   
 
 3577   
                     }
 3578   
                     break;
 3579   
 
 3580   
             }
 3581  70 
             retval.stop = input.LT(-1);
 3582   
 
 3583   
 
 3584  70 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3585  70 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3586   
 
 3587   
         }
 3588  0 
         catch (RecognitionException re) {
 3589  0 
             reportError(re);
 3590  0 
             recover(input,re);
 3591  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3592   
 
 3593   
         }
 3594   
 
 3595  0 
         finally {
 3596   
                 // do for sure before leaving
 3597  70 
         }
 3598  70 
         return retval;
 3599   
     }
 3600   
     // $ANTLR end "groupCondition"
 3601   
 
 3602   
 
 3603  16 
     public static class havingClause_return extends ParserRuleReturnScope {
 3604   
         Object tree;
 3605  16 
         public Object getTree() { return tree; }
 3606   
     };
 3607   
 
 3608   
 
 3609   
     // $ANTLR start "havingClause"
 3610   
     // com\\googlecode\\sparkleg\\Sparql.g:148:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3611   
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3612  16 
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3613  16 
         retval.start = input.LT(1);
 3614   
 
 3615   
 
 3616  16 
         Object root_0 = null;
 3617   
 
 3618  16 
         Token HAVING77=null;
 3619  16 
         SparqlParser.constraint_return constraint78 =null;
 3620   
 
 3621   
 
 3622  16 
         Object HAVING77_tree=null;
 3623  16 
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3624  16 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3625   
         try {
 3626   
             // com\\googlecode\\sparkleg\\Sparql.g:149:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3627   
             // com\\googlecode\\sparkleg\\Sparql.g:149:7: HAVING ( constraint )+
 3628   
             {
 3629  16 
             HAVING77=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause966);
 3630  16 
             stream_HAVING.add(HAVING77);
 3631   
 
 3632   
 
 3633   
             // com\\googlecode\\sparkleg\\Sparql.g:149:14: ( constraint )+
 3634  16 
             int cnt29=0;
 3635   
             loop29:
 3636   
             do {
 3637  32 
                 int alt29=2;
 3638  32 
                 switch ( input.LA(1) ) {
 3639   
                 case ABS:
 3640   
                 case BNODE:
 3641   
                 case BOUND:
 3642   
                 case CEIL:
 3643   
                 case COALESCE:
 3644   
                 case CONCAT:
 3645   
                 case CONTAINS:
 3646   
                 case DATATYPE:
 3647   
                 case DAY:
 3648   
                 case ENCODE_FOR_URI:
 3649   
                 case EXISTS:
 3650   
                 case FLOOR:
 3651   
                 case HOURS:
 3652   
                 case IF:
 3653   
                 case IRI:
 3654   
                 case IRI_REF:
 3655   
                 case ISBLANK:
 3656   
                 case ISIRI:
 3657   
                 case ISLITERAL:
 3658   
                 case ISNUMERIC:
 3659   
                 case ISURI:
 3660   
                 case LANG:
 3661   
                 case LANGMATCHES:
 3662   
                 case LCASE:
 3663   
                 case MD5:
 3664   
                 case MINUTES:
 3665   
                 case MONTH:
 3666   
                 case NOT:
 3667   
                 case NOW:
 3668   
                 case OPEN_BRACE:
 3669   
                 case PNAME_LN:
 3670   
                 case PNAME_NS:
 3671   
                 case RAND:
 3672   
                 case REGEX:
 3673   
                 case REPLACE:
 3674   
                 case ROUND:
 3675   
                 case SAMETERM:
 3676   
                 case SECONDS:
 3677   
                 case SHA1:
 3678   
                 case SHA224:
 3679   
                 case SHA256:
 3680   
                 case SHA384:
 3681   
                 case SHA512:
 3682   
                 case STR:
 3683   
                 case STRAFTER:
 3684   
                 case STRBEFORE:
 3685   
                 case STRDT:
 3686   
                 case STRENDS:
 3687   
                 case STRLANG:
 3688   
                 case STRLEN:
 3689   
                 case STRSTARTS:
 3690   
                 case SUBSTR:
 3691   
                 case TIMEZONE:
 3692   
                 case TZ:
 3693   
                 case UCASE:
 3694   
                 case URI:
 3695   
                 case YEAR:
 3696   
                     {
 3697  16 
                     alt29=1;
 3698   
                     }
 3699   
                     break;
 3700   
 
 3701   
                 }
 3702   
 
 3703  32 
                 switch (alt29) {
 3704   
                     case 1 :
 3705   
                         // com\\googlecode\\sparkleg\\Sparql.g:149:14: constraint
 3706   
                         {
 3707  16 
                         pushFollow(FOLLOW_constraint_in_havingClause968);
 3708  16 
                         constraint78=constraint();
 3709   
 
 3710  16 
                         state._fsp--;
 3711   
 
 3712  16 
                         stream_constraint.add(constraint78.getTree());
 3713   
 
 3714   
                         }
 3715  16 
                         break;
 3716   
 
 3717   
                     default :
 3718  16 
                         if ( cnt29 >= 1 ) break loop29;
 3719  0 
                         EarlyExitException eee =
 3720   
                             new EarlyExitException(29, input);
 3721  0 
                         throw eee;
 3722   
                 }
 3723  16 
                 cnt29++;
 3724  16 
             } while (true);
 3725   
 
 3726   
 
 3727   
             // AST REWRITE
 3728   
             // elements: HAVING, constraint
 3729   
             // token labels:
 3730   
             // rule labels: retval
 3731   
             // token list labels:
 3732   
             // rule list labels:
 3733   
             // wildcard labels:
 3734  16 
             retval.tree = root_0;
 3735  16 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3736   
 
 3737  16 
             root_0 = (Object)adaptor.nil();
 3738   
             // 149:26: -> ^( HAVING ( constraint )+ )
 3739   
             {
 3740   
                 // com\\googlecode\\sparkleg\\Sparql.g:149:29: ^( HAVING ( constraint )+ )
 3741   
                 {
 3742  16 
                 Object root_1 = (Object)adaptor.nil();
 3743  16 
                 root_1 = (Object)adaptor.becomeRoot(
 3744   
                 stream_HAVING.nextNode()
 3745   
                 , root_1);
 3746   
 
 3747  16 
                 if ( !(stream_constraint.hasNext()) ) {
 3748  0 
                     throw new RewriteEarlyExitException();
 3749   
                 }
 3750  32 
                 while ( stream_constraint.hasNext() ) {
 3751  16 
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3752   
 
 3753   
                 }
 3754  16 
                 stream_constraint.reset();
 3755   
 
 3756  16 
                 adaptor.addChild(root_0, root_1);
 3757   
                 }
 3758   
 
 3759   
             }
 3760   
 
 3761   
 
 3762  16 
             retval.tree = root_0;
 3763   
 
 3764   
             }
 3765   
 
 3766  16 
             retval.stop = input.LT(-1);
 3767   
 
 3768   
 
 3769  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3770  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3771   
 
 3772   
         }
 3773  0 
         catch (RecognitionException re) {
 3774  0 
             reportError(re);
 3775  0 
             recover(input,re);
 3776  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3777   
 
 3778   
         }
 3779   
 
 3780  0 
         finally {
 3781   
                 // do for sure before leaving
 3782  16 
         }
 3783  16 
         return retval;
 3784   
     }
 3785   
     // $ANTLR end "havingClause"
 3786   
 
 3787   
 
 3788  134 
     public static class orderClause_return extends ParserRuleReturnScope {
 3789   
         Object tree;
 3790  134 
         public Object getTree() { return tree; }
 3791   
     };
 3792   
 
 3793   
 
 3794   
     // $ANTLR start "orderClause"
 3795   
     // com\\googlecode\\sparkleg\\Sparql.g:152:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3796   
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3797  134 
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3798  134 
         retval.start = input.LT(1);
 3799   
 
 3800   
 
 3801  134 
         Object root_0 = null;
 3802   
 
 3803  134 
         Token ORDER79=null;
 3804  134 
         Token BY80=null;
 3805  134 
         SparqlParser.orderCondition_return orderCondition81 =null;
 3806   
 
 3807   
 
 3808  134 
         Object ORDER79_tree=null;
 3809  134 
         Object BY80_tree=null;
 3810  134 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3811  134 
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3812  134 
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3813   
         try {
 3814   
             // com\\googlecode\\sparkleg\\Sparql.g:153:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3815   
             // com\\googlecode\\sparkleg\\Sparql.g:153:7: ORDER BY ( orderCondition )+
 3816   
             {
 3817  134 
             ORDER79=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause1000);
 3818  134 
             stream_ORDER.add(ORDER79);
 3819   
 
 3820   
 
 3821  134 
             BY80=(Token)match(input,BY,FOLLOW_BY_in_orderClause1002);
 3822  134 
             stream_BY.add(BY80);
 3823   
 
 3824   
 
 3825   
             // com\\googlecode\\sparkleg\\Sparql.g:153:16: ( orderCondition )+
 3826  134 
             int cnt30=0;
 3827   
             loop30:
 3828   
             do {
 3829  316 
                 int alt30=2;
 3830  316 
                 switch ( input.LA(1) ) {
 3831   
                 case ABS:
 3832   
                 case ASC:
 3833   
                 case BNODE:
 3834   
                 case BOUND:
 3835   
                 case CEIL:
 3836   
                 case COALESCE:
 3837   
                 case CONCAT:
 3838   
                 case CONTAINS:
 3839   
                 case DATATYPE:
 3840   
                 case DAY:
 3841   
                 case DESC:
 3842   
                 case ENCODE_FOR_URI:
 3843   
                 case EXISTS:
 3844   
                 case FLOOR:
 3845   
                 case HOURS:
 3846   
                 case IF:
 3847   
                 case IRI:
 3848   
                 case IRI_REF:
 3849   
                 case ISBLANK:
 3850   
                 case ISIRI:
 3851   
                 case ISLITERAL:
 3852   
                 case ISNUMERIC:
 3853   
                 case ISURI:
 3854   
                 case LANG:
 3855   
                 case LANGMATCHES:
 3856   
                 case LCASE:
 3857   
                 case MD5:
 3858   
                 case MINUTES:
 3859   
                 case MONTH:
 3860   
                 case NOT:
 3861   
                 case NOW:
 3862   
                 case OPEN_BRACE:
 3863   
                 case PNAME_LN:
 3864   
                 case PNAME_NS:
 3865   
                 case RAND:
 3866   
                 case REGEX:
 3867   
                 case REPLACE:
 3868   
                 case ROUND:
 3869   
                 case SAMETERM:
 3870   
                 case SECONDS:
 3871   
                 case SHA1:
 3872   
                 case SHA224:
 3873   
                 case SHA256:
 3874   
                 case SHA384:
 3875   
                 case SHA512:
 3876   
                 case STR:
 3877   
                 case STRAFTER:
 3878   
                 case STRBEFORE:
 3879   
                 case STRDT:
 3880   
                 case STRENDS:
 3881   
                 case STRLANG:
 3882   
                 case STRLEN:
 3883   
                 case STRSTARTS:
 3884   
                 case SUBSTR:
 3885   
                 case TIMEZONE:
 3886   
                 case TZ:
 3887   
                 case UCASE:
 3888   
                 case URI:
 3889   
                 case VAR1:
 3890   
                 case VAR2:
 3891   
                 case YEAR:
 3892   
                     {
 3893  182 
                     alt30=1;
 3894   
                     }
 3895   
                     break;
 3896   
 
 3897   
                 }
 3898   
 
 3899  316 
                 switch (alt30) {
 3900   
                     case 1 :
 3901   
                         // com\\googlecode\\sparkleg\\Sparql.g:153:16: orderCondition
 3902   
                         {
 3903  182 
                         pushFollow(FOLLOW_orderCondition_in_orderClause1004);
 3904  182 
                         orderCondition81=orderCondition();
 3905   
 
 3906  182 
                         state._fsp--;
 3907   
 
 3908  182 
                         stream_orderCondition.add(orderCondition81.getTree());
 3909   
 
 3910   
                         }
 3911  182 
                         break;
 3912   
 
 3913   
                     default :
 3914  134 
                         if ( cnt30 >= 1 ) break loop30;
 3915  0 
                         EarlyExitException eee =
 3916   
                             new EarlyExitException(30, input);
 3917  0 
                         throw eee;
 3918   
                 }
 3919  182 
                 cnt30++;
 3920  182 
             } while (true);
 3921   
 
 3922   
 
 3923   
             // AST REWRITE
 3924   
             // elements: orderCondition
 3925   
             // token labels:
 3926   
             // rule labels: retval
 3927   
             // token list labels:
 3928   
             // rule list labels:
 3929   
             // wildcard labels:
 3930  134 
             retval.tree = root_0;
 3931  134 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3932   
 
 3933  134 
             root_0 = (Object)adaptor.nil();
 3934   
             // 153:32: -> ^( ORDER_BY ( orderCondition )+ )
 3935   
             {
 3936   
                 // com\\googlecode\\sparkleg\\Sparql.g:153:35: ^( ORDER_BY ( orderCondition )+ )
 3937   
                 {
 3938  134 
                 Object root_1 = (Object)adaptor.nil();
 3939  134 
                 root_1 = (Object)adaptor.becomeRoot(
 3940   
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 3941   
                 , root_1);
 3942   
 
 3943  134 
                 if ( !(stream_orderCondition.hasNext()) ) {
 3944  0 
                     throw new RewriteEarlyExitException();
 3945   
                 }
 3946  316 
                 while ( stream_orderCondition.hasNext() ) {
 3947  182 
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 3948   
 
 3949   
                 }
 3950  134 
                 stream_orderCondition.reset();
 3951   
 
 3952  134 
                 adaptor.addChild(root_0, root_1);
 3953   
                 }
 3954   
 
 3955   
             }
 3956   
 
 3957   
 
 3958  134 
             retval.tree = root_0;
 3959   
 
 3960   
             }
 3961   
 
 3962  134 
             retval.stop = input.LT(-1);
 3963   
 
 3964   
 
 3965  134 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3966  134 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3967   
 
 3968   
         }
 3969  0 
         catch (RecognitionException re) {
 3970  0 
             reportError(re);
 3971  0 
             recover(input,re);
 3972  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3973   
 
 3974   
         }
 3975   
 
 3976  0 
         finally {
 3977   
                 // do for sure before leaving
 3978  134 
         }
 3979  134 
         return retval;
 3980   
     }
 3981   
     // $ANTLR end "orderClause"
 3982   
 
 3983   
 
 3984  182 
     public static class orderCondition_return extends ParserRuleReturnScope {
 3985   
         Object tree;
 3986  182 
         public Object getTree() { return tree; }
 3987   
     };
 3988   
 
 3989   
 
 3990   
     // $ANTLR start "orderCondition"
 3991   
     // com\\googlecode\\sparkleg\\Sparql.g:156:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 3992   
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 3993  182 
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 3994  182 
         retval.start = input.LT(1);
 3995   
 
 3996   
 
 3997  182 
         Object root_0 = null;
 3998   
 
 3999  182 
         Token ASC82=null;
 4000  182 
         Token DESC84=null;
 4001  182 
         SparqlParser.brackettedExpression_return brackettedExpression83 =null;
 4002   
 
 4003  182 
         SparqlParser.brackettedExpression_return brackettedExpression85 =null;
 4004   
 
 4005  182 
         SparqlParser.constraint_return constraint86 =null;
 4006   
 
 4007  182 
         SparqlParser.var_return var87 =null;
 4008   
 
 4009   
 
 4010  182 
         Object ASC82_tree=null;
 4011  182 
         Object DESC84_tree=null;
 4012  182 
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4013  182 
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4014  182 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4015  182 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4016  182 
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4017   
         try {
 4018   
             // com\\googlecode\\sparkleg\\Sparql.g:157:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4019  182 
             int alt31=4;
 4020  182 
             switch ( input.LA(1) ) {
 4021   
             case ASC:
 4022   
                 {
 4023  10 
                 alt31=1;
 4024   
                 }
 4025  10 
                 break;
 4026   
             case DESC:
 4027   
                 {
 4028  30 
                 alt31=2;
 4029   
                 }
 4030  30 
                 break;
 4031   
             case ABS:
 4032   
             case BNODE:
 4033   
             case BOUND:
 4034   
             case CEIL:
 4035   
             case COALESCE:
 4036   
             case CONCAT:
 4037   
             case CONTAINS:
 4038   
             case DATATYPE:
 4039   
             case DAY:
 4040   
             case ENCODE_FOR_URI:
 4041   
             case EXISTS:
 4042   
             case FLOOR:
 4043   
             case HOURS:
 4044   
             case IF:
 4045   
             case IRI:
 4046   
             case IRI_REF:
 4047   
             case ISBLANK:
 4048   
             case ISIRI:
 4049   
             case ISLITERAL:
 4050   
             case ISNUMERIC:
 4051   
             case ISURI:
 4052   
             case LANG:
 4053   
             case LANGMATCHES:
 4054   
             case LCASE:
 4055   
             case MD5:
 4056   
             case MINUTES:
 4057   
             case MONTH:
 4058   
             case NOT:
 4059   
             case NOW:
 4060   
             case OPEN_BRACE:
 4061   
             case PNAME_LN:
 4062   
             case PNAME_NS:
 4063   
             case RAND:
 4064   
             case REGEX:
 4065   
             case REPLACE:
 4066   
             case ROUND:
 4067   
             case SAMETERM:
 4068   
             case SECONDS:
 4069   
             case SHA1:
 4070   
             case SHA224:
 4071   
             case SHA256:
 4072   
             case SHA384:
 4073   
             case SHA512:
 4074   
             case STR:
 4075   
             case STRAFTER:
 4076   
             case STRBEFORE:
 4077   
             case STRDT:
 4078   
             case STRENDS:
 4079   
             case STRLANG:
 4080   
             case STRLEN:
 4081   
             case STRSTARTS:
 4082   
             case SUBSTR:
 4083   
             case TIMEZONE:
 4084   
             case TZ:
 4085   
             case UCASE:
 4086   
             case URI:
 4087   
             case YEAR:
 4088   
                 {
 4089  12 
                 alt31=3;
 4090   
                 }
 4091  12 
                 break;
 4092   
             case VAR1:
 4093   
             case VAR2:
 4094   
                 {
 4095  130 
                 alt31=4;
 4096   
                 }
 4097  130 
                 break;
 4098   
             default:
 4099  0 
                 NoViableAltException nvae =
 4100   
                     new NoViableAltException("", 31, 0, input);
 4101   
 
 4102  0 
                 throw nvae;
 4103   
 
 4104   
             }
 4105   
 
 4106  182 
             switch (alt31) {
 4107   
                 case 1 :
 4108   
                     // com\\googlecode\\sparkleg\\Sparql.g:157:7: ASC brackettedExpression
 4109   
                     {
 4110  10 
                     ASC82=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1031);
 4111  10 
                     stream_ASC.add(ASC82);
 4112   
 
 4113   
 
 4114  10 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1033);
 4115  10 
                     brackettedExpression83=brackettedExpression();
 4116   
 
 4117  10 
                     state._fsp--;
 4118   
 
 4119  10 
                     stream_brackettedExpression.add(brackettedExpression83.getTree());
 4120   
 
 4121   
                     // AST REWRITE
 4122   
                     // elements: ASC, brackettedExpression
 4123   
                     // token labels:
 4124   
                     // rule labels: retval
 4125   
                     // token list labels:
 4126   
                     // rule list labels:
 4127   
                     // wildcard labels:
 4128  10 
                     retval.tree = root_0;
 4129  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4130   
 
 4131  10 
                     root_0 = (Object)adaptor.nil();
 4132   
                     // 157:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4133   
                     {
 4134   
                         // com\\googlecode\\sparkleg\\Sparql.g:157:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4135   
                         {
 4136  10 
                         Object root_1 = (Object)adaptor.nil();
 4137  10 
                         root_1 = (Object)adaptor.becomeRoot(
 4138   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4139   
                         , root_1);
 4140   
 
 4141  10 
                         adaptor.addChild(root_1,
 4142   
                         stream_ASC.nextNode()
 4143   
                         );
 4144   
 
 4145  10 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4146   
 
 4147  10 
                         adaptor.addChild(root_0, root_1);
 4148   
                         }
 4149   
 
 4150   
                     }
 4151   
 
 4152   
 
 4153  10 
                     retval.tree = root_0;
 4154   
 
 4155   
                     }
 4156  10 
                     break;
 4157   
                 case 2 :
 4158   
                     // com\\googlecode\\sparkleg\\Sparql.g:158:7: DESC brackettedExpression
 4159   
                     {
 4160  30 
                     DESC84=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1051);
 4161  30 
                     stream_DESC.add(DESC84);
 4162   
 
 4163   
 
 4164  30 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1053);
 4165  30 
                     brackettedExpression85=brackettedExpression();
 4166   
 
 4167  30 
                     state._fsp--;
 4168   
 
 4169  30 
                     stream_brackettedExpression.add(brackettedExpression85.getTree());
 4170   
 
 4171   
                     // AST REWRITE
 4172   
                     // elements: brackettedExpression, DESC
 4173   
                     // token labels:
 4174   
                     // rule labels: retval
 4175   
                     // token list labels:
 4176   
                     // rule list labels:
 4177   
                     // wildcard labels:
 4178  30 
                     retval.tree = root_0;
 4179  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4180   
 
 4181  30 
                     root_0 = (Object)adaptor.nil();
 4182   
                     // 158:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4183   
                     {
 4184   
                         // com\\googlecode\\sparkleg\\Sparql.g:158:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4185   
                         {
 4186  30 
                         Object root_1 = (Object)adaptor.nil();
 4187  30 
                         root_1 = (Object)adaptor.becomeRoot(
 4188   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4189   
                         , root_1);
 4190   
 
 4191  30 
                         adaptor.addChild(root_1,
 4192   
                         stream_DESC.nextNode()
 4193   
                         );
 4194   
 
 4195  30 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4196   
 
 4197  30 
                         adaptor.addChild(root_0, root_1);
 4198   
                         }
 4199   
 
 4200   
                     }
 4201   
 
 4202   
 
 4203  30 
                     retval.tree = root_0;
 4204   
 
 4205   
                     }
 4206  30 
                     break;
 4207   
                 case 3 :
 4208   
                     // com\\googlecode\\sparkleg\\Sparql.g:159:7: constraint
 4209   
                     {
 4210  12 
                     pushFollow(FOLLOW_constraint_in_orderCondition1071);
 4211  12 
                     constraint86=constraint();
 4212   
 
 4213  12 
                     state._fsp--;
 4214   
 
 4215  12 
                     stream_constraint.add(constraint86.getTree());
 4216   
 
 4217   
                     // AST REWRITE
 4218   
                     // elements: constraint
 4219   
                     // token labels:
 4220   
                     // rule labels: retval
 4221   
                     // token list labels:
 4222   
                     // rule list labels:
 4223   
                     // wildcard labels:
 4224  12 
                     retval.tree = root_0;
 4225  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4226   
 
 4227  12 
                     root_0 = (Object)adaptor.nil();
 4228   
                     // 159:18: -> ^( ORDER_CONDITION constraint )
 4229   
                     {
 4230   
                         // com\\googlecode\\sparkleg\\Sparql.g:159:21: ^( ORDER_CONDITION constraint )
 4231   
                         {
 4232  12 
                         Object root_1 = (Object)adaptor.nil();
 4233  12 
                         root_1 = (Object)adaptor.becomeRoot(
 4234   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4235   
                         , root_1);
 4236   
 
 4237  12 
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4238   
 
 4239  12 
                         adaptor.addChild(root_0, root_1);
 4240   
                         }
 4241   
 
 4242   
                     }
 4243   
 
 4244   
 
 4245  12 
                     retval.tree = root_0;
 4246   
 
 4247   
                     }
 4248  12 
                     break;
 4249   
                 case 4 :
 4250   
                     // com\\googlecode\\sparkleg\\Sparql.g:160:7: var
 4251   
                     {
 4252  130 
                     pushFollow(FOLLOW_var_in_orderCondition1087);
 4253  130 
                     var87=var();
 4254   
 
 4255  130 
                     state._fsp--;
 4256   
 
 4257  130 
                     stream_var.add(var87.getTree());
 4258   
 
 4259   
                     // AST REWRITE
 4260   
                     // elements: var
 4261   
                     // token labels:
 4262   
                     // rule labels: retval
 4263   
                     // token list labels:
 4264   
                     // rule list labels:
 4265   
                     // wildcard labels:
 4266  130 
                     retval.tree = root_0;
 4267  130 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4268   
 
 4269  130 
                     root_0 = (Object)adaptor.nil();
 4270   
                     // 160:11: -> ^( ORDER_CONDITION var )
 4271   
                     {
 4272   
                         // com\\googlecode\\sparkleg\\Sparql.g:160:14: ^( ORDER_CONDITION var )
 4273   
                         {
 4274  130 
                         Object root_1 = (Object)adaptor.nil();
 4275  130 
                         root_1 = (Object)adaptor.becomeRoot(
 4276   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4277   
                         , root_1);
 4278   
 
 4279  130 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4280   
 
 4281  130 
                         adaptor.addChild(root_0, root_1);
 4282   
                         }
 4283   
 
 4284   
                     }
 4285   
 
 4286   
 
 4287  130 
                     retval.tree = root_0;
 4288   
 
 4289   
                     }
 4290   
                     break;
 4291   
 
 4292   
             }
 4293  182 
             retval.stop = input.LT(-1);
 4294   
 
 4295   
 
 4296  182 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4297  182 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4298   
 
 4299   
         }
 4300  0 
         catch (RecognitionException re) {
 4301  0 
             reportError(re);
 4302  0 
             recover(input,re);
 4303  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4304   
 
 4305   
         }
 4306   
 
 4307  0 
         finally {
 4308   
                 // do for sure before leaving
 4309  182 
         }
 4310  182 
         return retval;
 4311   
     }
 4312   
     // $ANTLR end "orderCondition"
 4313   
 
 4314   
 
 4315  58 
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4316   
         Object tree;
 4317  58 
         public Object getTree() { return tree; }
 4318   
     };
 4319   
 
 4320   
 
 4321   
     // $ANTLR start "limitOffsetClauses"
 4322   
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4323   
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4324  58 
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4325  58 
         retval.start = input.LT(1);
 4326   
 
 4327   
 
 4328  58 
         Object root_0 = null;
 4329   
 
 4330  58 
         SparqlParser.limitClause_return limitClause88 =null;
 4331   
 
 4332  58 
         SparqlParser.offsetClause_return offsetClause89 =null;
 4333   
 
 4334  58 
         SparqlParser.offsetClause_return offsetClause90 =null;
 4335   
 
 4336  58 
         SparqlParser.limitClause_return limitClause91 =null;
 4337   
 
 4338   
 
 4339  58 
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4340  58 
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4341   
         try {
 4342   
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4343  58 
             int alt34=2;
 4344  58 
             switch ( input.LA(1) ) {
 4345   
             case LIMIT:
 4346   
                 {
 4347  38 
                 alt34=1;
 4348   
                 }
 4349  38 
                 break;
 4350   
             case OFFSET:
 4351   
                 {
 4352  20 
                 alt34=2;
 4353   
                 }
 4354  20 
                 break;
 4355   
             default:
 4356  0 
                 NoViableAltException nvae =
 4357   
                     new NoViableAltException("", 34, 0, input);
 4358   
 
 4359  0 
                 throw nvae;
 4360   
 
 4361   
             }
 4362   
 
 4363  58 
             switch (alt34) {
 4364   
                 case 1 :
 4365   
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: limitClause ( offsetClause )?
 4366   
                     {
 4367  38 
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1117);
 4368  38 
                     limitClause88=limitClause();
 4369   
 
 4370  38 
                     state._fsp--;
 4371   
 
 4372  38 
                     stream_limitClause.add(limitClause88.getTree());
 4373   
 
 4374   
                     // com\\googlecode\\sparkleg\\Sparql.g:164:19: ( offsetClause )?
 4375  38 
                     int alt32=2;
 4376  38 
                     switch ( input.LA(1) ) {
 4377   
                         case OFFSET:
 4378   
                             {
 4379  12 
                             alt32=1;
 4380   
                             }
 4381   
                             break;
 4382   
                     }
 4383   
 
 4384  38 
                     switch (alt32) {
 4385   
                         case 1 :
 4386   
                             // com\\googlecode\\sparkleg\\Sparql.g:164:19: offsetClause
 4387   
                             {
 4388  12 
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1119);
 4389  12 
                             offsetClause89=offsetClause();
 4390   
 
 4391  12 
                             state._fsp--;
 4392   
 
 4393  12 
                             stream_offsetClause.add(offsetClause89.getTree());
 4394   
 
 4395   
                             }
 4396   
                             break;
 4397   
 
 4398   
                     }
 4399   
 
 4400   
 
 4401   
                     // AST REWRITE
 4402   
                     // elements: limitClause, offsetClause
 4403   
                     // token labels:
 4404   
                     // rule labels: retval
 4405   
                     // token list labels:
 4406   
                     // rule list labels:
 4407   
                     // wildcard labels:
 4408  38 
                     retval.tree = root_0;
 4409  38 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4410   
 
 4411  38 
                     root_0 = (Object)adaptor.nil();
 4412   
                     // 164:33: -> limitClause ( offsetClause )*
 4413   
                     {
 4414  38 
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4415   
 
 4416   
                         // com\\googlecode\\sparkleg\\Sparql.g:164:48: ( offsetClause )*
 4417  50 
                         while ( stream_offsetClause.hasNext() ) {
 4418  12 
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4419   
 
 4420   
                         }
 4421  38 
                         stream_offsetClause.reset();
 4422   
 
 4423   
                     }
 4424   
 
 4425   
 
 4426  38 
                     retval.tree = root_0;
 4427   
 
 4428   
                     }
 4429  38 
                     break;
 4430   
                 case 2 :
 4431   
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: offsetClause ( limitClause )?
 4432   
                     {
 4433  20 
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1135);
 4434  20 
                     offsetClause90=offsetClause();
 4435   
 
 4436  20 
                     state._fsp--;
 4437   
 
 4438  20 
                     stream_offsetClause.add(offsetClause90.getTree());
 4439   
 
 4440   
                     // com\\googlecode\\sparkleg\\Sparql.g:165:20: ( limitClause )?
 4441  20 
                     int alt33=2;
 4442  20 
                     switch ( input.LA(1) ) {
 4443   
                         case LIMIT:
 4444   
                             {
 4445  10 
                             alt33=1;
 4446   
                             }
 4447   
                             break;
 4448   
                     }
 4449   
 
 4450  20 
                     switch (alt33) {
 4451   
                         case 1 :
 4452   
                             // com\\googlecode\\sparkleg\\Sparql.g:165:20: limitClause
 4453   
                             {
 4454  10 
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1137);
 4455  10 
                             limitClause91=limitClause();
 4456   
 
 4457  10 
                             state._fsp--;
 4458   
 
 4459  10 
                             stream_limitClause.add(limitClause91.getTree());
 4460   
 
 4461   
                             }
 4462   
                             break;
 4463   
 
 4464   
                     }
 4465   
 
 4466   
 
 4467   
                     // AST REWRITE
 4468   
                     // elements: limitClause, offsetClause
 4469   
                     // token labels:
 4470   
                     // rule labels: retval
 4471   
                     // token list labels:
 4472   
                     // rule list labels:
 4473   
                     // wildcard labels:
 4474  20 
                     retval.tree = root_0;
 4475  20 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4476   
 
 4477  20 
                     root_0 = (Object)adaptor.nil();
 4478   
                     // 165:33: -> offsetClause ( limitClause )*
 4479   
                     {
 4480  20 
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4481   
 
 4482   
                         // com\\googlecode\\sparkleg\\Sparql.g:165:49: ( limitClause )*
 4483  30 
                         while ( stream_limitClause.hasNext() ) {
 4484  10 
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4485   
 
 4486   
                         }
 4487  20 
                         stream_limitClause.reset();
 4488   
 
 4489   
                     }
 4490   
 
 4491   
 
 4492  20 
                     retval.tree = root_0;
 4493   
 
 4494   
                     }
 4495   
                     break;
 4496   
 
 4497   
             }
 4498  58 
             retval.stop = input.LT(-1);
 4499   
 
 4500   
 
 4501  58 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4502  58 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4503   
 
 4504   
         }
 4505  0 
         catch (RecognitionException re) {
 4506  0 
             reportError(re);
 4507  0 
             recover(input,re);
 4508  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4509   
 
 4510   
         }
 4511   
 
 4512  0 
         finally {
 4513   
                 // do for sure before leaving
 4514  58 
         }
 4515  58 
         return retval;
 4516   
     }
 4517   
     // $ANTLR end "limitOffsetClauses"
 4518   
 
 4519   
 
 4520  48 
     public static class limitClause_return extends ParserRuleReturnScope {
 4521   
         Object tree;
 4522  48 
         public Object getTree() { return tree; }
 4523   
     };
 4524   
 
 4525   
 
 4526   
     // $ANTLR start "limitClause"
 4527   
     // com\\googlecode\\sparkleg\\Sparql.g:168:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4528   
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4529  48 
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4530  48 
         retval.start = input.LT(1);
 4531   
 
 4532   
 
 4533  48 
         Object root_0 = null;
 4534   
 
 4535  48 
         Token LIMIT92=null;
 4536  48 
         Token INTEGER93=null;
 4537   
 
 4538  48 
         Object LIMIT92_tree=null;
 4539  48 
         Object INTEGER93_tree=null;
 4540  48 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4541  48 
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4542   
 
 4543   
         try {
 4544   
             // com\\googlecode\\sparkleg\\Sparql.g:169:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4545   
             // com\\googlecode\\sparkleg\\Sparql.g:169:7: LIMIT INTEGER
 4546   
             {
 4547  48 
             LIMIT92=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1162);
 4548  48 
             stream_LIMIT.add(LIMIT92);
 4549   
 
 4550   
 
 4551  48 
             INTEGER93=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1164);
 4552  48 
             stream_INTEGER.add(INTEGER93);
 4553   
 
 4554   
 
 4555   
             // AST REWRITE
 4556   
             // elements: LIMIT, INTEGER
 4557   
             // token labels:
 4558   
             // rule labels: retval
 4559   
             // token list labels:
 4560   
             // rule list labels:
 4561   
             // wildcard labels:
 4562  48 
             retval.tree = root_0;
 4563  48 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4564   
 
 4565  48 
             root_0 = (Object)adaptor.nil();
 4566   
             // 169:21: -> ^( LIMIT INTEGER )
 4567   
             {
 4568   
                 // com\\googlecode\\sparkleg\\Sparql.g:169:24: ^( LIMIT INTEGER )
 4569   
                 {
 4570  48 
                 Object root_1 = (Object)adaptor.nil();
 4571  48 
                 root_1 = (Object)adaptor.becomeRoot(
 4572   
                 stream_LIMIT.nextNode()
 4573   
                 , root_1);
 4574   
 
 4575  48 
                 adaptor.addChild(root_1,
 4576   
                 stream_INTEGER.nextNode()
 4577   
                 );
 4578   
 
 4579  48 
                 adaptor.addChild(root_0, root_1);
 4580   
                 }
 4581   
 
 4582   
             }
 4583   
 
 4584   
 
 4585  48 
             retval.tree = root_0;
 4586   
 
 4587   
             }
 4588   
 
 4589  48 
             retval.stop = input.LT(-1);
 4590   
 
 4591   
 
 4592  48 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4593  48 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4594   
 
 4595   
         }
 4596  0 
         catch (RecognitionException re) {
 4597  0 
             reportError(re);
 4598  0 
             recover(input,re);
 4599  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4600   
 
 4601   
         }
 4602   
 
 4603  0 
         finally {
 4604   
                 // do for sure before leaving
 4605  48 
         }
 4606  48 
         return retval;
 4607   
     }
 4608   
     // $ANTLR end "limitClause"
 4609   
 
 4610   
 
 4611  32 
     public static class offsetClause_return extends ParserRuleReturnScope {
 4612   
         Object tree;
 4613  32 
         public Object getTree() { return tree; }
 4614   
     };
 4615   
 
 4616   
 
 4617   
     // $ANTLR start "offsetClause"
 4618   
     // com\\googlecode\\sparkleg\\Sparql.g:172:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4619   
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4620  32 
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4621  32 
         retval.start = input.LT(1);
 4622   
 
 4623   
 
 4624  32 
         Object root_0 = null;
 4625   
 
 4626  32 
         Token OFFSET94=null;
 4627  32 
         Token INTEGER95=null;
 4628   
 
 4629  32 
         Object OFFSET94_tree=null;
 4630  32 
         Object INTEGER95_tree=null;
 4631  32 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4632  32 
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4633   
 
 4634   
         try {
 4635   
             // com\\googlecode\\sparkleg\\Sparql.g:173:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4636   
             // com\\googlecode\\sparkleg\\Sparql.g:173:7: OFFSET INTEGER
 4637   
             {
 4638  32 
             OFFSET94=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1189);
 4639  32 
             stream_OFFSET.add(OFFSET94);
 4640   
 
 4641   
 
 4642  32 
             INTEGER95=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1191);
 4643  32 
             stream_INTEGER.add(INTEGER95);
 4644   
 
 4645   
 
 4646   
             // AST REWRITE
 4647   
             // elements: INTEGER, OFFSET
 4648   
             // token labels:
 4649   
             // rule labels: retval
 4650   
             // token list labels:
 4651   
             // rule list labels:
 4652   
             // wildcard labels:
 4653  32 
             retval.tree = root_0;
 4654  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4655   
 
 4656  32 
             root_0 = (Object)adaptor.nil();
 4657   
             // 173:22: -> ^( OFFSET INTEGER )
 4658   
             {
 4659   
                 // com\\googlecode\\sparkleg\\Sparql.g:173:25: ^( OFFSET INTEGER )
 4660   
                 {
 4661  32 
                 Object root_1 = (Object)adaptor.nil();
 4662  32 
                 root_1 = (Object)adaptor.becomeRoot(
 4663   
                 stream_OFFSET.nextNode()
 4664   
                 , root_1);
 4665   
 
 4666  32 
                 adaptor.addChild(root_1,
 4667   
                 stream_INTEGER.nextNode()
 4668   
                 );
 4669   
 
 4670  32 
                 adaptor.addChild(root_0, root_1);
 4671   
                 }
 4672   
 
 4673   
             }
 4674   
 
 4675   
 
 4676  32 
             retval.tree = root_0;
 4677   
 
 4678   
             }
 4679   
 
 4680  32 
             retval.stop = input.LT(-1);
 4681   
 
 4682   
 
 4683  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4684  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4685   
 
 4686   
         }
 4687  0 
         catch (RecognitionException re) {
 4688  0 
             reportError(re);
 4689  0 
             recover(input,re);
 4690  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4691   
 
 4692   
         }
 4693   
 
 4694  0 
         finally {
 4695   
                 // do for sure before leaving
 4696  32 
         }
 4697  32 
         return retval;
 4698   
     }
 4699   
     // $ANTLR end "offsetClause"
 4700   
 
 4701   
 
 4702  1834 
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4703   
         Object tree;
 4704  1834 
         public Object getTree() { return tree; }
 4705   
     };
 4706   
 
 4707   
 
 4708   
     // $ANTLR start "bindingsClause"
 4709   
     // com\\googlecode\\sparkleg\\Sparql.g:176:1: bindingsClause : ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4710   
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4711  1834 
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4712  1834 
         retval.start = input.LT(1);
 4713   
 
 4714   
 
 4715  1834 
         Object root_0 = null;
 4716   
 
 4717  1834 
         Token BINDINGS96=null;
 4718  1834 
         Token OPEN_CURLY_BRACE98=null;
 4719  1834 
         Token CLOSE_CURLY_BRACE100=null;
 4720  1834 
         SparqlParser.var_return var97 =null;
 4721   
 
 4722  1834 
         SparqlParser.bindingValueList_return bindingValueList99 =null;
 4723   
 
 4724   
 
 4725  1834 
         Object BINDINGS96_tree=null;
 4726  1834 
         Object OPEN_CURLY_BRACE98_tree=null;
 4727  1834 
         Object CLOSE_CURLY_BRACE100_tree=null;
 4728  1834 
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4729  1834 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 4730  1834 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 4731  1834 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4732  1834 
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4733   
         try {
 4734   
             // com\\googlecode\\sparkleg\\Sparql.g:177:5: ( ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4735   
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4736   
             {
 4737   
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4738  1834 
             int alt37=2;
 4739  1834 
             switch ( input.LA(1) ) {
 4740   
                 case BINDINGS:
 4741   
                     {
 4742  26 
                     alt37=1;
 4743   
                     }
 4744   
                     break;
 4745   
             }
 4746   
 
 4747  1834 
             switch (alt37) {
 4748   
                 case 1 :
 4749   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:8: BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE
 4750   
                     {
 4751  26 
                     BINDINGS96=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1217);
 4752  26 
                     stream_BINDINGS.add(BINDINGS96);
 4753   
 
 4754   
 
 4755   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:17: ( var )*
 4756   
                     loop35:
 4757   
                     do {
 4758  64 
                         int alt35=2;
 4759  64 
                         switch ( input.LA(1) ) {
 4760   
                         case VAR1:
 4761   
                         case VAR2:
 4762   
                             {
 4763  38 
                             alt35=1;
 4764   
                             }
 4765   
                             break;
 4766   
 
 4767   
                         }
 4768   
 
 4769  64 
                         switch (alt35) {
 4770   
                             case 1 :
 4771   
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:17: var
 4772   
                                 {
 4773  38 
                                 pushFollow(FOLLOW_var_in_bindingsClause1219);
 4774  38 
                                 var97=var();
 4775   
 
 4776  38 
                                 state._fsp--;
 4777   
 
 4778  38 
                                 stream_var.add(var97.getTree());
 4779   
 
 4780   
                                 }
 4781  38 
                                 break;
 4782   
 
 4783   
                             default :
 4784  26 
                                 break loop35;
 4785   
                         }
 4786  38 
                     } while (true);
 4787   
 
 4788   
 
 4789  26 
                     OPEN_CURLY_BRACE98=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1222);
 4790  26 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE98);
 4791   
 
 4792   
 
 4793   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:39: ( bindingValueList )*
 4794   
                     loop36:
 4795   
                     do {
 4796  60 
                         int alt36=2;
 4797  60 
                         switch ( input.LA(1) ) {
 4798   
                         case OPEN_BRACE:
 4799   
                             {
 4800  34 
                             alt36=1;
 4801   
                             }
 4802   
                             break;
 4803   
 
 4804   
                         }
 4805   
 
 4806  60 
                         switch (alt36) {
 4807   
                             case 1 :
 4808   
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:39: bindingValueList
 4809   
                                 {
 4810  34 
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1224);
 4811  34 
                                 bindingValueList99=bindingValueList();
 4812   
 
 4813  34 
                                 state._fsp--;
 4814   
 
 4815  34 
                                 stream_bindingValueList.add(bindingValueList99.getTree());
 4816   
 
 4817   
                                 }
 4818  34 
                                 break;
 4819   
 
 4820   
                             default :
 4821  26 
                                 break loop36;
 4822   
                         }
 4823  34 
                     } while (true);
 4824   
 
 4825   
 
 4826  26 
                     CLOSE_CURLY_BRACE100=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1227);
 4827  26 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE100);
 4828   
 
 4829   
 
 4830   
                     }
 4831   
                     break;
 4832   
 
 4833   
             }
 4834   
 
 4835   
 
 4836   
             // AST REWRITE
 4837   
             // elements: var, bindingValueList, BINDINGS
 4838   
             // token labels:
 4839   
             // rule labels: retval
 4840   
             // token list labels:
 4841   
             // rule list labels:
 4842   
             // wildcard labels:
 4843  1834 
             retval.tree = root_0;
 4844  1834 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4845   
 
 4846  1834 
             root_0 = (Object)adaptor.nil();
 4847   
             // 177:77: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4848   
             {
 4849   
                 // com\\googlecode\\sparkleg\\Sparql.g:177:80: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4850  1834 
                 if ( stream_var.hasNext()||stream_bindingValueList.hasNext()||stream_BINDINGS.hasNext() ) {
 4851   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:80: ^( BINDINGS ( var )* ( bindingValueList )* )
 4852   
                     {
 4853  26 
                     Object root_1 = (Object)adaptor.nil();
 4854  26 
                     root_1 = (Object)adaptor.becomeRoot(
 4855   
                     stream_BINDINGS.nextNode()
 4856   
                     , root_1);
 4857   
 
 4858   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:91: ( var )*
 4859  64 
                     while ( stream_var.hasNext() ) {
 4860  38 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4861   
 
 4862   
                     }
 4863  26 
                     stream_var.reset();
 4864   
 
 4865   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:96: ( bindingValueList )*
 4866  60 
                     while ( stream_bindingValueList.hasNext() ) {
 4867  34 
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4868   
 
 4869   
                     }
 4870  26 
                     stream_bindingValueList.reset();
 4871   
 
 4872  26 
                     adaptor.addChild(root_0, root_1);
 4873   
                     }
 4874   
 
 4875   
                 }
 4876  1834 
                 stream_var.reset();
 4877  1834 
                 stream_bindingValueList.reset();
 4878  1834 
                 stream_BINDINGS.reset();
 4879   
 
 4880   
             }
 4881   
 
 4882   
 
 4883  1834 
             retval.tree = root_0;
 4884   
 
 4885   
             }
 4886   
 
 4887  1834 
             retval.stop = input.LT(-1);
 4888   
 
 4889   
 
 4890  1834 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4891  1834 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4892   
 
 4893   
         }
 4894  0 
         catch (RecognitionException re) {
 4895  0 
             reportError(re);
 4896  0 
             recover(input,re);
 4897  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4898   
 
 4899   
         }
 4900   
 
 4901  0 
         finally {
 4902   
                 // do for sure before leaving
 4903  1834 
         }
 4904  1834 
         return retval;
 4905   
     }
 4906   
     // $ANTLR end "bindingsClause"
 4907   
 
 4908   
 
 4909  34 
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4910   
         Object tree;
 4911  34 
         public Object getTree() { return tree; }
 4912   
     };
 4913   
 
 4914   
 
 4915   
     // $ANTLR start "bindingValueList"
 4916   
     // com\\googlecode\\sparkleg\\Sparql.g:180:1: bindingValueList : OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4917   
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4918  34 
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4919  34 
         retval.start = input.LT(1);
 4920   
 
 4921   
 
 4922  34 
         Object root_0 = null;
 4923   
 
 4924  34 
         Token OPEN_BRACE101=null;
 4925  34 
         Token CLOSE_BRACE103=null;
 4926  34 
         SparqlParser.bindingValue_return bindingValue102 =null;
 4927   
 
 4928   
 
 4929  34 
         Object OPEN_BRACE101_tree=null;
 4930  34 
         Object CLOSE_BRACE103_tree=null;
 4931  34 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 4932  34 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 4933  34 
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 4934   
         try {
 4935   
             // com\\googlecode\\sparkleg\\Sparql.g:181:5: ( OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) )
 4936   
             // com\\googlecode\\sparkleg\\Sparql.g:181:7: OPEN_BRACE ( bindingValue )* CLOSE_BRACE
 4937   
             {
 4938  34 
             OPEN_BRACE101=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bindingValueList1263);
 4939  34 
             stream_OPEN_BRACE.add(OPEN_BRACE101);
 4940   
 
 4941   
 
 4942   
             // com\\googlecode\\sparkleg\\Sparql.g:181:18: ( bindingValue )*
 4943   
             loop38:
 4944   
             do {
 4945  88 
                 int alt38=2;
 4946  88 
                 switch ( input.LA(1) ) {
 4947   
                 case DECIMAL:
 4948   
                 case DECIMAL_NEGATIVE:
 4949   
                 case DECIMAL_POSITIVE:
 4950   
                 case DOUBLE:
 4951   
                 case DOUBLE_NEGATIVE:
 4952   
                 case DOUBLE_POSITIVE:
 4953   
                 case FALSE:
 4954   
                 case INTEGER:
 4955   
                 case INTEGER_NEGATIVE:
 4956   
                 case INTEGER_POSITIVE:
 4957   
                 case IRI_REF:
 4958   
                 case PNAME_LN:
 4959   
                 case PNAME_NS:
 4960   
                 case STRING_LITERAL1:
 4961   
                 case STRING_LITERAL2:
 4962   
                 case STRING_LITERAL_LONG1:
 4963   
                 case STRING_LITERAL_LONG2:
 4964   
                 case TRUE:
 4965   
                 case UNDEF:
 4966   
                     {
 4967  54 
                     alt38=1;
 4968   
                     }
 4969   
                     break;
 4970   
 
 4971   
                 }
 4972   
 
 4973  88 
                 switch (alt38) {
 4974   
                     case 1 :
 4975   
                         // com\\googlecode\\sparkleg\\Sparql.g:181:18: bindingValue
 4976   
                         {
 4977  54 
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1265);
 4978  54 
                         bindingValue102=bindingValue();
 4979   
 
 4980  54 
                         state._fsp--;
 4981   
 
 4982  54 
                         stream_bindingValue.add(bindingValue102.getTree());
 4983   
 
 4984   
                         }
 4985  54 
                         break;
 4986   
 
 4987   
                     default :
 4988  34 
                         break loop38;
 4989   
                 }
 4990  54 
             } while (true);
 4991   
 
 4992   
 
 4993  34 
             CLOSE_BRACE103=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bindingValueList1268);
 4994  34 
             stream_CLOSE_BRACE.add(CLOSE_BRACE103);
 4995   
 
 4996   
 
 4997   
             // AST REWRITE
 4998   
             // elements: bindingValue
 4999   
             // token labels:
 5000   
             // rule labels: retval
 5001   
             // token list labels:
 5002   
             // rule list labels:
 5003   
             // wildcard labels:
 5004  34 
             retval.tree = root_0;
 5005  34 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5006   
 
 5007  34 
             root_0 = (Object)adaptor.nil();
 5008   
             // 181:44: -> ^( BINDING_VALUE ( bindingValue )* )
 5009   
             {
 5010   
                 // com\\googlecode\\sparkleg\\Sparql.g:181:47: ^( BINDING_VALUE ( bindingValue )* )
 5011   
                 {
 5012  34 
                 Object root_1 = (Object)adaptor.nil();
 5013  34 
                 root_1 = (Object)adaptor.becomeRoot(
 5014   
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5015   
                 , root_1);
 5016   
 
 5017   
                 // com\\googlecode\\sparkleg\\Sparql.g:181:63: ( bindingValue )*
 5018  88 
                 while ( stream_bindingValue.hasNext() ) {
 5019  54 
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5020   
 
 5021   
                 }
 5022  34 
                 stream_bindingValue.reset();
 5023   
 
 5024  34 
                 adaptor.addChild(root_0, root_1);
 5025   
                 }
 5026   
 
 5027   
             }
 5028   
 
 5029   
 
 5030  34 
             retval.tree = root_0;
 5031   
 
 5032   
             }
 5033   
 
 5034  34 
             retval.stop = input.LT(-1);
 5035   
 
 5036   
 
 5037  34 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5038  34 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5039   
 
 5040   
         }
 5041  0 
         catch (RecognitionException re) {
 5042  0 
             reportError(re);
 5043  0 
             recover(input,re);
 5044  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5045   
 
 5046   
         }
 5047   
 
 5048  0 
         finally {
 5049   
                 // do for sure before leaving
 5050  34 
         }
 5051  34 
         return retval;
 5052   
     }
 5053   
     // $ANTLR end "bindingValueList"
 5054   
 
 5055   
 
 5056  54 
     public static class bindingValue_return extends ParserRuleReturnScope {
 5057   
         Object tree;
 5058  54 
         public Object getTree() { return tree; }
 5059   
     };
 5060   
 
 5061   
 
 5062   
     // $ANTLR start "bindingValue"
 5063   
     // com\\googlecode\\sparkleg\\Sparql.g:184:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5064   
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5065  54 
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5066  54 
         retval.start = input.LT(1);
 5067   
 
 5068   
 
 5069  54 
         Object root_0 = null;
 5070   
 
 5071  54 
         Token UNDEF108=null;
 5072  54 
         SparqlParser.iriRef_return iriRef104 =null;
 5073   
 
 5074  54 
         SparqlParser.rdfLiteral_return rdfLiteral105 =null;
 5075   
 
 5076  54 
         SparqlParser.numericLiteral_return numericLiteral106 =null;
 5077   
 
 5078  54 
         SparqlParser.booleanLiteral_return booleanLiteral107 =null;
 5079   
 
 5080   
 
 5081  54 
         Object UNDEF108_tree=null;
 5082   
 
 5083   
         try {
 5084   
             // com\\googlecode\\sparkleg\\Sparql.g:185:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5085  54 
             int alt39=5;
 5086  54 
             switch ( input.LA(1) ) {
 5087   
             case IRI_REF:
 5088   
             case PNAME_LN:
 5089   
             case PNAME_NS:
 5090   
                 {
 5091  22 
                 alt39=1;
 5092   
                 }
 5093  22 
                 break;
 5094   
             case STRING_LITERAL1:
 5095   
             case STRING_LITERAL2:
 5096   
             case STRING_LITERAL_LONG1:
 5097   
             case STRING_LITERAL_LONG2:
 5098   
                 {
 5099  14 
                 alt39=2;
 5100   
                 }
 5101  14 
                 break;
 5102   
             case DECIMAL:
 5103   
             case DECIMAL_NEGATIVE:
 5104   
             case DECIMAL_POSITIVE:
 5105   
             case DOUBLE:
 5106   
             case DOUBLE_NEGATIVE:
 5107   
             case DOUBLE_POSITIVE:
 5108   
             case INTEGER:
 5109   
             case INTEGER_NEGATIVE:
 5110   
             case INTEGER_POSITIVE:
 5111   
                 {
 5112  0 
                 alt39=3;
 5113   
                 }
 5114  0 
                 break;
 5115   
             case FALSE:
 5116   
             case TRUE:
 5117   
                 {
 5118  0 
                 alt39=4;
 5119   
                 }
 5120  0 
                 break;
 5121   
             case UNDEF:
 5122   
                 {
 5123  18 
                 alt39=5;
 5124   
                 }
 5125  18 
                 break;
 5126   
             default:
 5127  0 
                 NoViableAltException nvae =
 5128   
                     new NoViableAltException("", 39, 0, input);
 5129   
 
 5130  0 
                 throw nvae;
 5131   
 
 5132   
             }
 5133   
 
 5134  54 
             switch (alt39) {
 5135   
                 case 1 :
 5136   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:7: iriRef
 5137   
                     {
 5138  22 
                     root_0 = (Object)adaptor.nil();
 5139   
 
 5140   
 
 5141  22 
                     pushFollow(FOLLOW_iriRef_in_bindingValue1299);
 5142  22 
                     iriRef104=iriRef();
 5143   
 
 5144  22 
                     state._fsp--;
 5145   
 
 5146  22 
                     adaptor.addChild(root_0, iriRef104.getTree());
 5147   
 
 5148   
                     }
 5149  22 
                     break;
 5150   
                 case 2 :
 5151   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:16: rdfLiteral
 5152   
                     {
 5153  14 
                     root_0 = (Object)adaptor.nil();
 5154   
 
 5155   
 
 5156  14 
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1303);
 5157  14 
                     rdfLiteral105=rdfLiteral();
 5158   
 
 5159  14 
                     state._fsp--;
 5160   
 
 5161  14 
                     adaptor.addChild(root_0, rdfLiteral105.getTree());
 5162   
 
 5163   
                     }
 5164  14 
                     break;
 5165   
                 case 3 :
 5166   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:29: numericLiteral
 5167   
                     {
 5168  0 
                     root_0 = (Object)adaptor.nil();
 5169   
 
 5170   
 
 5171  0 
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1307);
 5172  0 
                     numericLiteral106=numericLiteral();
 5173   
 
 5174  0 
                     state._fsp--;
 5175   
 
 5176  0 
                     adaptor.addChild(root_0, numericLiteral106.getTree());
 5177   
 
 5178   
                     }
 5179  0 
                     break;
 5180   
                 case 4 :
 5181   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:46: booleanLiteral
 5182   
                     {
 5183  0 
                     root_0 = (Object)adaptor.nil();
 5184   
 
 5185   
 
 5186  0 
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1311);
 5187  0 
                     booleanLiteral107=booleanLiteral();
 5188   
 
 5189  0 
                     state._fsp--;
 5190   
 
 5191  0 
                     adaptor.addChild(root_0, booleanLiteral107.getTree());
 5192   
 
 5193   
                     }
 5194  0 
                     break;
 5195   
                 case 5 :
 5196   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:63: UNDEF
 5197   
                     {
 5198  18 
                     root_0 = (Object)adaptor.nil();
 5199   
 
 5200   
 
 5201  18 
                     UNDEF108=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1315);
 5202  18 
                     UNDEF108_tree =
 5203   
                     (Object)adaptor.create(UNDEF108)
 5204   
                     ;
 5205  18 
                     adaptor.addChild(root_0, UNDEF108_tree);
 5206   
 
 5207   
 
 5208   
                     }
 5209   
                     break;
 5210   
 
 5211   
             }
 5212  54 
             retval.stop = input.LT(-1);
 5213   
 
 5214   
 
 5215  54 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5216  54 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5217   
 
 5218   
         }
 5219  0 
         catch (RecognitionException re) {
 5220  0 
             reportError(re);
 5221  0 
             recover(input,re);
 5222  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5223   
 
 5224   
         }
 5225   
 
 5226  0 
         finally {
 5227   
                 // do for sure before leaving
 5228  54 
         }
 5229  54 
         return retval;
 5230   
     }
 5231   
     // $ANTLR end "bindingValue"
 5232   
 
 5233   
 
 5234  128 
     public static class update_return extends ParserRuleReturnScope {
 5235   
         Object tree;
 5236  128 
         public Object getTree() { return tree; }
 5237   
     };
 5238   
 
 5239   
 
 5240   
     // $ANTLR start "update"
 5241   
     // com\\googlecode\\sparkleg\\Sparql.g:188:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5242   
     public final SparqlParser.update_return update() throws RecognitionException {
 5243  128 
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5244  128 
         retval.start = input.LT(1);
 5245   
 
 5246   
 
 5247  128 
         Object root_0 = null;
 5248   
 
 5249  128 
         SparqlParser.prologue_return prologue109 =null;
 5250   
 
 5251  128 
         SparqlParser.load_return load110 =null;
 5252   
 
 5253  128 
         SparqlParser.clear_return clear111 =null;
 5254   
 
 5255  128 
         SparqlParser.drop_return drop112 =null;
 5256   
 
 5257  128 
         SparqlParser.add_return add113 =null;
 5258   
 
 5259  128 
         SparqlParser.move_return move114 =null;
 5260   
 
 5261  128 
         SparqlParser.copy_return copy115 =null;
 5262   
 
 5263  128 
         SparqlParser.create_return create116 =null;
 5264   
 
 5265  128 
         SparqlParser.insert_return insert117 =null;
 5266   
 
 5267  128 
         SparqlParser.delete_return delete118 =null;
 5268   
 
 5269  128 
         SparqlParser.modify_return modify119 =null;
 5270   
 
 5271   
 
 5272  128 
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5273  128 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5274  128 
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5275  128 
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5276  128 
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5277  128 
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5278  128 
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5279  128 
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5280  128 
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5281  128 
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5282  128 
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5283   
         try {
 5284   
             // com\\googlecode\\sparkleg\\Sparql.g:189:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5285   
             // com\\googlecode\\sparkleg\\Sparql.g:189:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5286   
             {
 5287  128 
             pushFollow(FOLLOW_prologue_in_update1336);
 5288  128 
             prologue109=prologue();
 5289   
 
 5290  128 
             state._fsp--;
 5291   
 
 5292  128 
             stream_prologue.add(prologue109.getTree());
 5293   
 
 5294   
             // com\\googlecode\\sparkleg\\Sparql.g:189:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5295  128 
             int alt40=10;
 5296  128 
             switch ( input.LA(1) ) {
 5297   
             case LOAD:
 5298   
                 {
 5299  0 
                 alt40=1;
 5300   
                 }
 5301  0 
                 break;
 5302   
             case CLEAR:
 5303   
                 {
 5304  8 
                 alt40=2;
 5305   
                 }
 5306  8 
                 break;
 5307   
             case DROP:
 5308   
                 {
 5309  8 
                 alt40=3;
 5310   
                 }
 5311  8 
                 break;
 5312   
             case ADD:
 5313   
                 {
 5314  0 
                 alt40=4;
 5315   
                 }
 5316  0 
                 break;
 5317   
             case MOVE:
 5318   
                 {
 5319  0 
                 alt40=5;
 5320   
                 }
 5321  0 
                 break;
 5322   
             case COPY:
 5323   
                 {
 5324  0 
                 alt40=6;
 5325   
                 }
 5326  0 
                 break;
 5327   
             case CREATE:
 5328   
                 {
 5329  0 
                 alt40=7;
 5330   
                 }
 5331  0 
                 break;
 5332   
             case INSERT:
 5333   
                 {
 5334  20 
                 switch ( input.LA(2) ) {
 5335   
                 case DATA:
 5336   
                     {
 5337  8 
                     alt40=8;
 5338   
                     }
 5339  8 
                     break;
 5340   
                 case OPEN_CURLY_BRACE:
 5341   
                     {
 5342  12 
                     alt40=10;
 5343   
                     }
 5344  12 
                     break;
 5345   
                 default:
 5346  0 
                     NoViableAltException nvae =
 5347   
                         new NoViableAltException("", 40, 8, input);
 5348   
 
 5349  0 
                     throw nvae;
 5350   
 
 5351   
                 }
 5352   
 
 5353   
                 }
 5354  20 
                 break;
 5355   
             case DELETE:
 5356   
                 {
 5357  78 
                 switch ( input.LA(2) ) {
 5358   
                 case DATA:
 5359   
                 case WHERE:
 5360   
                     {
 5361  24 
                     alt40=9;
 5362   
                     }
 5363  24 
                     break;
 5364   
                 case OPEN_CURLY_BRACE:
 5365   
                     {
 5366  54 
                     alt40=10;
 5367   
                     }
 5368  54 
                     break;
 5369   
                 default:
 5370  0 
                     NoViableAltException nvae =
 5371   
                         new NoViableAltException("", 40, 9, input);
 5372   
 
 5373  0 
                     throw nvae;
 5374   
 
 5375   
                 }
 5376   
 
 5377   
                 }
 5378  78 
                 break;
 5379   
             case WITH:
 5380   
                 {
 5381  14 
                 alt40=10;
 5382   
                 }
 5383  14 
                 break;
 5384   
             default:
 5385  0 
                 NoViableAltException nvae =
 5386   
                     new NoViableAltException("", 40, 0, input);
 5387   
 
 5388  0 
                 throw nvae;
 5389   
 
 5390   
             }
 5391   
 
 5392  128 
             switch (alt40) {
 5393   
                 case 1 :
 5394   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:17: load
 5395   
                     {
 5396  0 
                     pushFollow(FOLLOW_load_in_update1339);
 5397  0 
                     load110=load();
 5398   
 
 5399  0 
                     state._fsp--;
 5400   
 
 5401  0 
                     stream_load.add(load110.getTree());
 5402   
 
 5403   
                     }
 5404  0 
                     break;
 5405   
                 case 2 :
 5406   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:24: clear
 5407   
                     {
 5408  8 
                     pushFollow(FOLLOW_clear_in_update1343);
 5409  8 
                     clear111=clear();
 5410   
 
 5411  8 
                     state._fsp--;
 5412   
 
 5413  8 
                     stream_clear.add(clear111.getTree());
 5414   
 
 5415   
                     }
 5416  8 
                     break;
 5417   
                 case 3 :
 5418   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:32: drop
 5419   
                     {
 5420  8 
                     pushFollow(FOLLOW_drop_in_update1347);
 5421  8 
                     drop112=drop();
 5422   
 
 5423  8 
                     state._fsp--;
 5424   
 
 5425  8 
                     stream_drop.add(drop112.getTree());
 5426   
 
 5427   
                     }
 5428  8 
                     break;
 5429   
                 case 4 :
 5430   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:39: add
 5431   
                     {
 5432  0 
                     pushFollow(FOLLOW_add_in_update1351);
 5433  0 
                     add113=add();
 5434   
 
 5435  0 
                     state._fsp--;
 5436   
 
 5437  0 
                     stream_add.add(add113.getTree());
 5438   
 
 5439   
                     }
 5440  0 
                     break;
 5441   
                 case 5 :
 5442   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:45: move
 5443   
                     {
 5444  0 
                     pushFollow(FOLLOW_move_in_update1355);
 5445  0 
                     move114=move();
 5446   
 
 5447  0 
                     state._fsp--;
 5448   
 
 5449  0 
                     stream_move.add(move114.getTree());
 5450   
 
 5451   
                     }
 5452  0 
                     break;
 5453   
                 case 6 :
 5454   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:52: copy
 5455   
                     {
 5456  0 
                     pushFollow(FOLLOW_copy_in_update1359);
 5457  0 
                     copy115=copy();
 5458   
 
 5459  0 
                     state._fsp--;
 5460   
 
 5461  0 
                     stream_copy.add(copy115.getTree());
 5462   
 
 5463   
                     }
 5464  0 
                     break;
 5465   
                 case 7 :
 5466   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:59: create
 5467   
                     {
 5468  0 
                     pushFollow(FOLLOW_create_in_update1363);
 5469  0 
                     create116=create();
 5470   
 
 5471  0 
                     state._fsp--;
 5472   
 
 5473  0 
                     stream_create.add(create116.getTree());
 5474   
 
 5475   
                     }
 5476  0 
                     break;
 5477   
                 case 8 :
 5478   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:68: insert
 5479   
                     {
 5480  8 
                     pushFollow(FOLLOW_insert_in_update1367);
 5481  8 
                     insert117=insert();
 5482   
 
 5483  8 
                     state._fsp--;
 5484   
 
 5485  8 
                     stream_insert.add(insert117.getTree());
 5486   
 
 5487   
                     }
 5488  8 
                     break;
 5489   
                 case 9 :
 5490   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:77: delete
 5491   
                     {
 5492  24 
                     pushFollow(FOLLOW_delete_in_update1371);
 5493  24 
                     delete118=delete();
 5494   
 
 5495  24 
                     state._fsp--;
 5496   
 
 5497  24 
                     stream_delete.add(delete118.getTree());
 5498   
 
 5499   
                     }
 5500  24 
                     break;
 5501   
                 case 10 :
 5502   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:86: modify
 5503   
                     {
 5504  80 
                     pushFollow(FOLLOW_modify_in_update1375);
 5505  80 
                     modify119=modify();
 5506   
 
 5507  80 
                     state._fsp--;
 5508   
 
 5509  80 
                     stream_modify.add(modify119.getTree());
 5510   
 
 5511   
                     }
 5512   
                     break;
 5513   
 
 5514   
             }
 5515   
 
 5516   
 
 5517   
             // AST REWRITE
 5518   
             // elements: create, modify, prologue, copy, insert, delete, clear, move, add, drop, load
 5519   
             // token labels:
 5520   
             // rule labels: retval
 5521   
             // token list labels:
 5522   
             // rule list labels:
 5523   
             // wildcard labels:
 5524  128 
             retval.tree = root_0;
 5525  128 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5526   
 
 5527  128 
             root_0 = (Object)adaptor.nil();
 5528   
             // 189:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5529   
             {
 5530  128 
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5531   
 
 5532   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:106: ( load )*
 5533  128 
                 while ( stream_load.hasNext() ) {
 5534  0 
                     adaptor.addChild(root_0, stream_load.nextTree());
 5535   
 
 5536   
                 }
 5537  128 
                 stream_load.reset();
 5538   
 
 5539   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:112: ( clear )*
 5540  136 
                 while ( stream_clear.hasNext() ) {
 5541  8 
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5542   
 
 5543   
                 }
 5544  128 
                 stream_clear.reset();
 5545   
 
 5546   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:119: ( drop )*
 5547  136 
                 while ( stream_drop.hasNext() ) {
 5548  8 
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5549   
 
 5550   
                 }
 5551  128 
                 stream_drop.reset();
 5552   
 
 5553   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:125: ( add )*
 5554  128 
                 while ( stream_add.hasNext() ) {
 5555  0 
                     adaptor.addChild(root_0, stream_add.nextTree());
 5556   
 
 5557   
                 }
 5558  128 
                 stream_add.reset();
 5559   
 
 5560   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:130: ( move )*
 5561  128 
                 while ( stream_move.hasNext() ) {
 5562  0 
                     adaptor.addChild(root_0, stream_move.nextTree());
 5563   
 
 5564   
                 }
 5565  128 
                 stream_move.reset();
 5566   
 
 5567   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:136: ( copy )*
 5568  128 
                 while ( stream_copy.hasNext() ) {
 5569  0 
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5570   
 
 5571   
                 }
 5572  128 
                 stream_copy.reset();
 5573   
 
 5574   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:142: ( create )*
 5575  128 
                 while ( stream_create.hasNext() ) {
 5576  0 
                     adaptor.addChild(root_0, stream_create.nextTree());
 5577   
 
 5578   
                 }
 5579  128 
                 stream_create.reset();
 5580   
 
 5581   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:150: ( insert )*
 5582  136 
                 while ( stream_insert.hasNext() ) {
 5583  8 
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5584   
 
 5585   
                 }
 5586  128 
                 stream_insert.reset();
 5587   
 
 5588   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:158: ( delete )*
 5589  152 
                 while ( stream_delete.hasNext() ) {
 5590  24 
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5591   
 
 5592   
                 }
 5593  128 
                 stream_delete.reset();
 5594   
 
 5595   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:166: ( modify )*
 5596  208 
                 while ( stream_modify.hasNext() ) {
 5597  80 
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5598   
 
 5599   
                 }
 5600  128 
                 stream_modify.reset();
 5601   
 
 5602   
             }
 5603   
 
 5604   
 
 5605  128 
             retval.tree = root_0;
 5606   
 
 5607   
             }
 5608   
 
 5609  128 
             retval.stop = input.LT(-1);
 5610   
 
 5611   
 
 5612  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5613  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5614   
 
 5615   
         }
 5616  0 
         catch (RecognitionException re) {
 5617  0 
             reportError(re);
 5618  0 
             recover(input,re);
 5619  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5620   
 
 5621   
         }
 5622   
 
 5623  0 
         finally {
 5624   
                 // do for sure before leaving
 5625  128 
         }
 5626  128 
         return retval;
 5627   
     }
 5628   
     // $ANTLR end "update"
 5629   
 
 5630   
 
 5631  0 
     public static class load_return extends ParserRuleReturnScope {
 5632   
         Object tree;
 5633  0 
         public Object getTree() { return tree; }
 5634   
     };
 5635   
 
 5636   
 
 5637   
     // $ANTLR start "load"
 5638   
     // com\\googlecode\\sparkleg\\Sparql.g:192:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5639   
     public final SparqlParser.load_return load() throws RecognitionException {
 5640  0 
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5641  0 
         retval.start = input.LT(1);
 5642   
 
 5643   
 
 5644  0 
         Object root_0 = null;
 5645   
 
 5646  0 
         Token LOAD120=null;
 5647  0 
         Token SILENT121=null;
 5648  0 
         Token INTO123=null;
 5649  0 
         SparqlParser.iriRef_return iriRef122 =null;
 5650   
 
 5651  0 
         SparqlParser.graphRef_return graphRef124 =null;
 5652   
 
 5653   
 
 5654  0 
         Object LOAD120_tree=null;
 5655  0 
         Object SILENT121_tree=null;
 5656  0 
         Object INTO123_tree=null;
 5657  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5658  0 
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5659  0 
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5660  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5661  0 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5662   
         try {
 5663   
             // com\\googlecode\\sparkleg\\Sparql.g:193:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5664   
             // com\\googlecode\\sparkleg\\Sparql.g:193:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5665   
             {
 5666  0 
             LOAD120=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1438);
 5667  0 
             stream_LOAD.add(LOAD120);
 5668   
 
 5669   
 
 5670   
             // com\\googlecode\\sparkleg\\Sparql.g:193:12: ( SILENT )?
 5671  0 
             int alt41=2;
 5672  0 
             switch ( input.LA(1) ) {
 5673   
                 case SILENT:
 5674   
                     {
 5675  0 
                     alt41=1;
 5676   
                     }
 5677   
                     break;
 5678   
             }
 5679   
 
 5680  0 
             switch (alt41) {
 5681   
                 case 1 :
 5682   
                     // com\\googlecode\\sparkleg\\Sparql.g:193:12: SILENT
 5683   
                     {
 5684  0 
                     SILENT121=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1440);
 5685  0 
                     stream_SILENT.add(SILENT121);
 5686   
 
 5687   
 
 5688   
                     }
 5689   
                     break;
 5690   
 
 5691   
             }
 5692   
 
 5693   
 
 5694  0 
             pushFollow(FOLLOW_iriRef_in_load1443);
 5695  0 
             iriRef122=iriRef();
 5696   
 
 5697  0 
             state._fsp--;
 5698   
 
 5699  0 
             stream_iriRef.add(iriRef122.getTree());
 5700   
 
 5701   
             // com\\googlecode\\sparkleg\\Sparql.g:193:27: ( INTO graphRef )?
 5702  0 
             int alt42=2;
 5703  0 
             switch ( input.LA(1) ) {
 5704   
                 case INTO:
 5705   
                     {
 5706  0 
                     alt42=1;
 5707   
                     }
 5708   
                     break;
 5709   
             }
 5710   
 
 5711  0 
             switch (alt42) {
 5712   
                 case 1 :
 5713   
                     // com\\googlecode\\sparkleg\\Sparql.g:193:28: INTO graphRef
 5714   
                     {
 5715  0 
                     INTO123=(Token)match(input,INTO,FOLLOW_INTO_in_load1446);
 5716  0 
                     stream_INTO.add(INTO123);
 5717   
 
 5718   
 
 5719  0 
                     pushFollow(FOLLOW_graphRef_in_load1448);
 5720  0 
                     graphRef124=graphRef();
 5721   
 
 5722  0 
                     state._fsp--;
 5723   
 
 5724  0 
                     stream_graphRef.add(graphRef124.getTree());
 5725   
 
 5726   
                     }
 5727   
                     break;
 5728   
 
 5729   
             }
 5730   
 
 5731   
 
 5732   
             // AST REWRITE
 5733   
             // elements: iriRef, LOAD, SILENT, graphRef
 5734   
             // token labels:
 5735   
             // rule labels: retval
 5736   
             // token list labels:
 5737   
             // rule list labels:
 5738   
             // wildcard labels:
 5739  0 
             retval.tree = root_0;
 5740  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5741   
 
 5742  0 
             root_0 = (Object)adaptor.nil();
 5743   
             // 193:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5744   
             {
 5745   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5746   
                 {
 5747  0 
                 Object root_1 = (Object)adaptor.nil();
 5748  0 
                 root_1 = (Object)adaptor.becomeRoot(
 5749   
                 stream_LOAD.nextNode()
 5750   
                 , root_1);
 5751   
 
 5752   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:54: ( SILENT )*
 5753  0 
                 while ( stream_SILENT.hasNext() ) {
 5754  0 
                     adaptor.addChild(root_1,
 5755   
                     stream_SILENT.nextNode()
 5756   
                     );
 5757   
 
 5758   
                 }
 5759  0 
                 stream_SILENT.reset();
 5760   
 
 5761  0 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5762   
 
 5763   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:69: ( graphRef )?
 5764  0 
                 if ( stream_graphRef.hasNext() ) {
 5765  0 
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5766   
 
 5767   
                 }
 5768  0 
                 stream_graphRef.reset();
 5769   
 
 5770  0 
                 adaptor.addChild(root_0, root_1);
 5771   
                 }
 5772   
 
 5773   
             }
 5774   
 
 5775   
 
 5776  0 
             retval.tree = root_0;
 5777   
 
 5778   
             }
 5779   
 
 5780  0 
             retval.stop = input.LT(-1);
 5781   
 
 5782   
 
 5783  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5784  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5785   
 
 5786   
         }
 5787  0 
         catch (RecognitionException re) {
 5788  0 
             reportError(re);
 5789  0 
             recover(input,re);
 5790  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5791   
 
 5792   
         }
 5793   
 
 5794  0 
         finally {
 5795   
                 // do for sure before leaving
 5796  0 
         }
 5797  0 
         return retval;
 5798   
     }
 5799   
     // $ANTLR end "load"
 5800   
 
 5801   
 
 5802  8 
     public static class clear_return extends ParserRuleReturnScope {
 5803   
         Object tree;
 5804  8 
         public Object getTree() { return tree; }
 5805   
     };
 5806   
 
 5807   
 
 5808   
     // $ANTLR start "clear"
 5809   
     // com\\googlecode\\sparkleg\\Sparql.g:196:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5810   
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5811  8 
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5812  8 
         retval.start = input.LT(1);
 5813   
 
 5814   
 
 5815  8 
         Object root_0 = null;
 5816   
 
 5817  8 
         Token CLEAR125=null;
 5818  8 
         Token SILENT126=null;
 5819  8 
         SparqlParser.graphRefAll_return graphRefAll127 =null;
 5820   
 
 5821   
 
 5822  8 
         Object CLEAR125_tree=null;
 5823  8 
         Object SILENT126_tree=null;
 5824  8 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5825  8 
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5826  8 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5827   
         try {
 5828   
             // com\\googlecode\\sparkleg\\Sparql.g:197:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5829   
             // com\\googlecode\\sparkleg\\Sparql.g:197:7: CLEAR ( SILENT )? graphRefAll
 5830   
             {
 5831  8 
             CLEAR125=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1485);
 5832  8 
             stream_CLEAR.add(CLEAR125);
 5833   
 
 5834   
 
 5835   
             // com\\googlecode\\sparkleg\\Sparql.g:197:14: ( SILENT )?
 5836  8 
             int alt43=2;
 5837  8 
             switch ( input.LA(1) ) {
 5838   
                 case SILENT:
 5839   
                     {
 5840  0 
                     alt43=1;
 5841   
                     }
 5842   
                     break;
 5843   
             }
 5844   
 
 5845  8 
             switch (alt43) {
 5846   
                 case 1 :
 5847   
                     // com\\googlecode\\sparkleg\\Sparql.g:197:14: SILENT
 5848   
                     {
 5849  0 
                     SILENT126=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1488);
 5850  0 
                     stream_SILENT.add(SILENT126);
 5851   
 
 5852   
 
 5853   
                     }
 5854   
                     break;
 5855   
 
 5856   
             }
 5857   
 
 5858   
 
 5859  8 
             pushFollow(FOLLOW_graphRefAll_in_clear1491);
 5860  8 
             graphRefAll127=graphRefAll();
 5861   
 
 5862  8 
             state._fsp--;
 5863   
 
 5864  8 
             stream_graphRefAll.add(graphRefAll127.getTree());
 5865   
 
 5866   
             // AST REWRITE
 5867   
             // elements: CLEAR, graphRefAll, SILENT
 5868   
             // token labels:
 5869   
             // rule labels: retval
 5870   
             // token list labels:
 5871   
             // rule list labels:
 5872   
             // wildcard labels:
 5873  8 
             retval.tree = root_0;
 5874  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5875   
 
 5876  8 
             root_0 = (Object)adaptor.nil();
 5877   
             // 197:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5878   
             {
 5879   
                 // com\\googlecode\\sparkleg\\Sparql.g:197:37: ^( CLEAR ( SILENT )* graphRefAll )
 5880   
                 {
 5881  8 
                 Object root_1 = (Object)adaptor.nil();
 5882  8 
                 root_1 = (Object)adaptor.becomeRoot(
 5883   
                 stream_CLEAR.nextNode()
 5884   
                 , root_1);
 5885   
 
 5886   
                 // com\\googlecode\\sparkleg\\Sparql.g:197:45: ( SILENT )*
 5887  8 
                 while ( stream_SILENT.hasNext() ) {
 5888  0 
                     adaptor.addChild(root_1,
 5889   
                     stream_SILENT.nextNode()
 5890   
                     );
 5891   
 
 5892   
                 }
 5893  8 
                 stream_SILENT.reset();
 5894   
 
 5895  8 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5896   
 
 5897  8 
                 adaptor.addChild(root_0, root_1);
 5898   
                 }
 5899   
 
 5900   
             }
 5901   
 
 5902   
 
 5903  8 
             retval.tree = root_0;
 5904   
 
 5905   
             }
 5906   
 
 5907  8 
             retval.stop = input.LT(-1);
 5908   
 
 5909   
 
 5910  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5911  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5912   
 
 5913   
         }
 5914  0 
         catch (RecognitionException re) {
 5915  0 
             reportError(re);
 5916  0 
             recover(input,re);
 5917  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5918   
 
 5919   
         }
 5920   
 
 5921  0 
         finally {
 5922   
                 // do for sure before leaving
 5923  8 
         }
 5924  8 
         return retval;
 5925   
     }
 5926   
     // $ANTLR end "clear"
 5927   
 
 5928   
 
 5929  8 
     public static class drop_return extends ParserRuleReturnScope {
 5930   
         Object tree;
 5931  8 
         public Object getTree() { return tree; }
 5932   
     };
 5933   
 
 5934   
 
 5935   
     // $ANTLR start "drop"
 5936   
     // com\\googlecode\\sparkleg\\Sparql.g:200:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 5937   
     public final SparqlParser.drop_return drop() throws RecognitionException {
 5938  8 
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 5939  8 
         retval.start = input.LT(1);
 5940   
 
 5941   
 
 5942  8 
         Object root_0 = null;
 5943   
 
 5944  8 
         Token DROP128=null;
 5945  8 
         Token SILENT129=null;
 5946  8 
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5947   
 
 5948   
 
 5949  8 
         Object DROP128_tree=null;
 5950  8 
         Object SILENT129_tree=null;
 5951  8 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5952  8 
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 5953  8 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5954   
         try {
 5955   
             // com\\googlecode\\sparkleg\\Sparql.g:201:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 5956   
             // com\\googlecode\\sparkleg\\Sparql.g:201:7: DROP ( SILENT )? graphRefAll
 5957   
             {
 5958  8 
             DROP128=(Token)match(input,DROP,FOLLOW_DROP_in_drop1523);
 5959  8 
             stream_DROP.add(DROP128);
 5960   
 
 5961   
 
 5962   
             // com\\googlecode\\sparkleg\\Sparql.g:201:12: ( SILENT )?
 5963  8 
             int alt44=2;
 5964  8 
             switch ( input.LA(1) ) {
 5965   
                 case SILENT:
 5966   
                     {
 5967  0 
                     alt44=1;
 5968   
                     }
 5969   
                     break;
 5970   
             }
 5971   
 
 5972  8 
             switch (alt44) {
 5973   
                 case 1 :
 5974   
                     // com\\googlecode\\sparkleg\\Sparql.g:201:12: SILENT
 5975   
                     {
 5976  0 
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1525);
 5977  0 
                     stream_SILENT.add(SILENT129);
 5978   
 
 5979   
 
 5980   
                     }
 5981   
                     break;
 5982   
 
 5983   
             }
 5984   
 
 5985   
 
 5986  8 
             pushFollow(FOLLOW_graphRefAll_in_drop1528);
 5987  8 
             graphRefAll130=graphRefAll();
 5988   
 
 5989  8 
             state._fsp--;
 5990   
 
 5991  8 
             stream_graphRefAll.add(graphRefAll130.getTree());
 5992   
 
 5993   
             // AST REWRITE
 5994   
             // elements: SILENT, DROP, graphRefAll
 5995   
             // token labels:
 5996   
             // rule labels: retval
 5997   
             // token list labels:
 5998   
             // rule list labels:
 5999   
             // wildcard labels:
 6000  8 
             retval.tree = root_0;
 6001  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6002   
 
 6003  8 
             root_0 = (Object)adaptor.nil();
 6004   
             // 201:32: -> ^( DROP ( SILENT )* graphRefAll )
 6005   
             {
 6006   
                 // com\\googlecode\\sparkleg\\Sparql.g:201:35: ^( DROP ( SILENT )* graphRefAll )
 6007   
                 {
 6008  8 
                 Object root_1 = (Object)adaptor.nil();
 6009  8 
                 root_1 = (Object)adaptor.becomeRoot(
 6010   
                 stream_DROP.nextNode()
 6011   
                 , root_1);
 6012   
 
 6013   
                 // com\\googlecode\\sparkleg\\Sparql.g:201:42: ( SILENT )*
 6014  8 
                 while ( stream_SILENT.hasNext() ) {
 6015  0 
                     adaptor.addChild(root_1,
 6016   
                     stream_SILENT.nextNode()
 6017   
                     );
 6018   
 
 6019   
                 }
 6020  8 
                 stream_SILENT.reset();
 6021   
 
 6022  8 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6023   
 
 6024  8 
                 adaptor.addChild(root_0, root_1);
 6025   
                 }
 6026   
 
 6027   
             }
 6028   
 
 6029   
 
 6030  8 
             retval.tree = root_0;
 6031   
 
 6032   
             }
 6033   
 
 6034  8 
             retval.stop = input.LT(-1);
 6035   
 
 6036   
 
 6037  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6038  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6039   
 
 6040   
         }
 6041  0 
         catch (RecognitionException re) {
 6042  0 
             reportError(re);
 6043  0 
             recover(input,re);
 6044  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6045   
 
 6046   
         }
 6047   
 
 6048  0 
         finally {
 6049   
                 // do for sure before leaving
 6050  8 
         }
 6051  8 
         return retval;
 6052   
     }
 6053   
     // $ANTLR end "drop"
 6054   
 
 6055   
 
 6056  0 
     public static class create_return extends ParserRuleReturnScope {
 6057   
         Object tree;
 6058  0 
         public Object getTree() { return tree; }
 6059   
     };
 6060   
 
 6061   
 
 6062   
     // $ANTLR start "create"
 6063   
     // com\\googlecode\\sparkleg\\Sparql.g:204:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6064   
     public final SparqlParser.create_return create() throws RecognitionException {
 6065  0 
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6066  0 
         retval.start = input.LT(1);
 6067   
 
 6068   
 
 6069  0 
         Object root_0 = null;
 6070   
 
 6071  0 
         Token CREATE131=null;
 6072  0 
         Token SILENT132=null;
 6073  0 
         SparqlParser.graphRef_return graphRef133 =null;
 6074   
 
 6075   
 
 6076  0 
         Object CREATE131_tree=null;
 6077  0 
         Object SILENT132_tree=null;
 6078  0 
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6079  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6080  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6081   
         try {
 6082   
             // com\\googlecode\\sparkleg\\Sparql.g:205:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6083   
             // com\\googlecode\\sparkleg\\Sparql.g:205:7: CREATE ( SILENT )? graphRef
 6084   
             {
 6085  0 
             CREATE131=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1557);
 6086  0 
             stream_CREATE.add(CREATE131);
 6087   
 
 6088   
 
 6089   
             // com\\googlecode\\sparkleg\\Sparql.g:205:14: ( SILENT )?
 6090  0 
             int alt45=2;
 6091  0 
             switch ( input.LA(1) ) {
 6092   
                 case SILENT:
 6093   
                     {
 6094  0 
                     alt45=1;
 6095   
                     }
 6096   
                     break;
 6097   
             }
 6098   
 
 6099  0 
             switch (alt45) {
 6100   
                 case 1 :
 6101   
                     // com\\googlecode\\sparkleg\\Sparql.g:205:14: SILENT
 6102   
                     {
 6103  0 
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1559);
 6104  0 
                     stream_SILENT.add(SILENT132);
 6105   
 
 6106   
 
 6107   
                     }
 6108   
                     break;
 6109   
 
 6110   
             }
 6111   
 
 6112   
 
 6113  0 
             pushFollow(FOLLOW_graphRef_in_create1562);
 6114  0 
             graphRef133=graphRef();
 6115   
 
 6116  0 
             state._fsp--;
 6117   
 
 6118  0 
             stream_graphRef.add(graphRef133.getTree());
 6119   
 
 6120   
             // AST REWRITE
 6121   
             // elements: graphRef, SILENT, CREATE
 6122   
             // token labels:
 6123   
             // rule labels: retval
 6124   
             // token list labels:
 6125   
             // rule list labels:
 6126   
             // wildcard labels:
 6127  0 
             retval.tree = root_0;
 6128  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6129   
 
 6130  0 
             root_0 = (Object)adaptor.nil();
 6131   
             // 205:31: -> ^( CREATE ( SILENT )* graphRef )
 6132   
             {
 6133   
                 // com\\googlecode\\sparkleg\\Sparql.g:205:34: ^( CREATE ( SILENT )* graphRef )
 6134   
                 {
 6135  0 
                 Object root_1 = (Object)adaptor.nil();
 6136  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6137   
                 stream_CREATE.nextNode()
 6138   
                 , root_1);
 6139   
 
 6140   
                 // com\\googlecode\\sparkleg\\Sparql.g:205:43: ( SILENT )*
 6141  0 
                 while ( stream_SILENT.hasNext() ) {
 6142  0 
                     adaptor.addChild(root_1,
 6143   
                     stream_SILENT.nextNode()
 6144   
                     );
 6145   
 
 6146   
                 }
 6147  0 
                 stream_SILENT.reset();
 6148   
 
 6149  0 
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6150   
 
 6151  0 
                 adaptor.addChild(root_0, root_1);
 6152   
                 }
 6153   
 
 6154   
             }
 6155   
 
 6156   
 
 6157  0 
             retval.tree = root_0;
 6158   
 
 6159   
             }
 6160   
 
 6161  0 
             retval.stop = input.LT(-1);
 6162   
 
 6163   
 
 6164  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6165  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6166   
 
 6167   
         }
 6168  0 
         catch (RecognitionException re) {
 6169  0 
             reportError(re);
 6170  0 
             recover(input,re);
 6171  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6172   
 
 6173   
         }
 6174   
 
 6175  0 
         finally {
 6176   
                 // do for sure before leaving
 6177  0 
         }
 6178  0 
         return retval;
 6179   
     }
 6180   
     // $ANTLR end "create"
 6181   
 
 6182   
 
 6183  0 
     public static class add_return extends ParserRuleReturnScope {
 6184   
         Object tree;
 6185  0 
         public Object getTree() { return tree; }
 6186   
     };
 6187   
 
 6188   
 
 6189   
     // $ANTLR start "add"
 6190   
     // com\\googlecode\\sparkleg\\Sparql.g:208:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6191   
     public final SparqlParser.add_return add() throws RecognitionException {
 6192  0 
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6193  0 
         retval.start = input.LT(1);
 6194   
 
 6195   
 
 6196  0 
         Object root_0 = null;
 6197   
 
 6198  0 
         Token ADD134=null;
 6199  0 
         Token SILENT135=null;
 6200  0 
         Token TO136=null;
 6201  0 
         SparqlParser.graphOrDefault_return from =null;
 6202   
 
 6203  0 
         SparqlParser.graphOrDefault_return to =null;
 6204   
 
 6205   
 
 6206  0 
         Object ADD134_tree=null;
 6207  0 
         Object SILENT135_tree=null;
 6208  0 
         Object TO136_tree=null;
 6209  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6210  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6211  0 
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6212  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6213   
         try {
 6214   
             // com\\googlecode\\sparkleg\\Sparql.g:209:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6215   
             // com\\googlecode\\sparkleg\\Sparql.g:209:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6216   
             {
 6217  0 
             ADD134=(Token)match(input,ADD,FOLLOW_ADD_in_add1594);
 6218  0 
             stream_ADD.add(ADD134);
 6219   
 
 6220   
 
 6221   
             // com\\googlecode\\sparkleg\\Sparql.g:209:11: ( SILENT )?
 6222  0 
             int alt46=2;
 6223  0 
             switch ( input.LA(1) ) {
 6224   
                 case SILENT:
 6225   
                     {
 6226  0 
                     alt46=1;
 6227   
                     }
 6228   
                     break;
 6229   
             }
 6230   
 
 6231  0 
             switch (alt46) {
 6232   
                 case 1 :
 6233   
                     // com\\googlecode\\sparkleg\\Sparql.g:209:11: SILENT
 6234   
                     {
 6235  0 
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1596);
 6236  0 
                     stream_SILENT.add(SILENT135);
 6237   
 
 6238   
 
 6239   
                     }
 6240   
                     break;
 6241   
 
 6242   
             }
 6243   
 
 6244   
 
 6245  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1601);
 6246  0 
             from=graphOrDefault();
 6247   
 
 6248  0 
             state._fsp--;
 6249   
 
 6250  0 
             stream_graphOrDefault.add(from.getTree());
 6251   
 
 6252  0 
             TO136=(Token)match(input,TO,FOLLOW_TO_in_add1603);
 6253  0 
             stream_TO.add(TO136);
 6254   
 
 6255   
 
 6256  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1607);
 6257  0 
             to=graphOrDefault();
 6258   
 
 6259  0 
             state._fsp--;
 6260   
 
 6261  0 
             stream_graphOrDefault.add(to.getTree());
 6262   
 
 6263   
             // AST REWRITE
 6264   
             // elements: from, SILENT, ADD, to
 6265   
             // token labels:
 6266   
             // rule labels: to, retval, from
 6267   
             // token list labels:
 6268   
             // rule list labels:
 6269   
             // wildcard labels:
 6270  0 
             retval.tree = root_0;
 6271  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6272  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6273  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6274   
 
 6275  0 
             root_0 = (Object)adaptor.nil();
 6276   
             // 209:60: -> ^( ADD ( SILENT )* $from $to)
 6277   
             {
 6278   
                 // com\\googlecode\\sparkleg\\Sparql.g:209:63: ^( ADD ( SILENT )* $from $to)
 6279   
                 {
 6280  0 
                 Object root_1 = (Object)adaptor.nil();
 6281  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6282   
                 stream_ADD.nextNode()
 6283   
                 , root_1);
 6284   
 
 6285   
                 // com\\googlecode\\sparkleg\\Sparql.g:209:69: ( SILENT )*
 6286  0 
                 while ( stream_SILENT.hasNext() ) {
 6287  0 
                     adaptor.addChild(root_1,
 6288   
                     stream_SILENT.nextNode()
 6289   
                     );
 6290   
 
 6291   
                 }
 6292  0 
                 stream_SILENT.reset();
 6293   
 
 6294  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6295   
 
 6296  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6297   
 
 6298  0 
                 adaptor.addChild(root_0, root_1);
 6299   
                 }
 6300   
 
 6301   
             }
 6302   
 
 6303   
 
 6304  0 
             retval.tree = root_0;
 6305   
 
 6306   
             }
 6307   
 
 6308  0 
             retval.stop = input.LT(-1);
 6309   
 
 6310   
 
 6311  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6312  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6313   
 
 6314   
         }
 6315  0 
         catch (RecognitionException re) {
 6316  0 
             reportError(re);
 6317  0 
             recover(input,re);
 6318  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6319   
 
 6320   
         }
 6321   
 
 6322  0 
         finally {
 6323   
                 // do for sure before leaving
 6324  0 
         }
 6325  0 
         return retval;
 6326   
     }
 6327   
     // $ANTLR end "add"
 6328   
 
 6329   
 
 6330  0 
     public static class move_return extends ParserRuleReturnScope {
 6331   
         Object tree;
 6332  0 
         public Object getTree() { return tree; }
 6333   
     };
 6334   
 
 6335   
 
 6336   
     // $ANTLR start "move"
 6337   
     // com\\googlecode\\sparkleg\\Sparql.g:212:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6338   
     public final SparqlParser.move_return move() throws RecognitionException {
 6339  0 
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6340  0 
         retval.start = input.LT(1);
 6341   
 
 6342   
 
 6343  0 
         Object root_0 = null;
 6344   
 
 6345  0 
         Token MOVE137=null;
 6346  0 
         Token SILENT138=null;
 6347  0 
         Token TO139=null;
 6348  0 
         SparqlParser.graphOrDefault_return from =null;
 6349   
 
 6350  0 
         SparqlParser.graphOrDefault_return to =null;
 6351   
 
 6352   
 
 6353  0 
         Object MOVE137_tree=null;
 6354  0 
         Object SILENT138_tree=null;
 6355  0 
         Object TO139_tree=null;
 6356  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6357  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6358  0 
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6359  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6360   
         try {
 6361   
             // com\\googlecode\\sparkleg\\Sparql.g:213:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6362   
             // com\\googlecode\\sparkleg\\Sparql.g:213:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6363   
             {
 6364  0 
             MOVE137=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1643);
 6365  0 
             stream_MOVE.add(MOVE137);
 6366   
 
 6367   
 
 6368   
             // com\\googlecode\\sparkleg\\Sparql.g:213:12: ( SILENT )?
 6369  0 
             int alt47=2;
 6370  0 
             switch ( input.LA(1) ) {
 6371   
                 case SILENT:
 6372   
                     {
 6373  0 
                     alt47=1;
 6374   
                     }
 6375   
                     break;
 6376   
             }
 6377   
 
 6378  0 
             switch (alt47) {
 6379   
                 case 1 :
 6380   
                     // com\\googlecode\\sparkleg\\Sparql.g:213:12: SILENT
 6381   
                     {
 6382  0 
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1645);
 6383  0 
                     stream_SILENT.add(SILENT138);
 6384   
 
 6385   
 
 6386   
                     }
 6387   
                     break;
 6388   
 
 6389   
             }
 6390   
 
 6391   
 
 6392  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1650);
 6393  0 
             from=graphOrDefault();
 6394   
 
 6395  0 
             state._fsp--;
 6396   
 
 6397  0 
             stream_graphOrDefault.add(from.getTree());
 6398   
 
 6399  0 
             TO139=(Token)match(input,TO,FOLLOW_TO_in_move1652);
 6400  0 
             stream_TO.add(TO139);
 6401   
 
 6402   
 
 6403  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1656);
 6404  0 
             to=graphOrDefault();
 6405   
 
 6406  0 
             state._fsp--;
 6407   
 
 6408  0 
             stream_graphOrDefault.add(to.getTree());
 6409   
 
 6410   
             // AST REWRITE
 6411   
             // elements: MOVE, to, SILENT, from
 6412   
             // token labels:
 6413   
             // rule labels: to, retval, from
 6414   
             // token list labels:
 6415   
             // rule list labels:
 6416   
             // wildcard labels:
 6417  0 
             retval.tree = root_0;
 6418  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6419  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6420  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6421   
 
 6422  0 
             root_0 = (Object)adaptor.nil();
 6423   
             // 213:61: -> ^( MOVE ( SILENT )* $from $to)
 6424   
             {
 6425   
                 // com\\googlecode\\sparkleg\\Sparql.g:213:64: ^( MOVE ( SILENT )* $from $to)
 6426   
                 {
 6427  0 
                 Object root_1 = (Object)adaptor.nil();
 6428  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6429   
                 stream_MOVE.nextNode()
 6430   
                 , root_1);
 6431   
 
 6432   
                 // com\\googlecode\\sparkleg\\Sparql.g:213:71: ( SILENT )*
 6433  0 
                 while ( stream_SILENT.hasNext() ) {
 6434  0 
                     adaptor.addChild(root_1,
 6435   
                     stream_SILENT.nextNode()
 6436   
                     );
 6437   
 
 6438   
                 }
 6439  0 
                 stream_SILENT.reset();
 6440   
 
 6441  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6442   
 
 6443  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6444   
 
 6445  0 
                 adaptor.addChild(root_0, root_1);
 6446   
                 }
 6447   
 
 6448   
             }
 6449   
 
 6450   
 
 6451  0 
             retval.tree = root_0;
 6452   
 
 6453   
             }
 6454   
 
 6455  0 
             retval.stop = input.LT(-1);
 6456   
 
 6457   
 
 6458  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6459  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6460   
 
 6461   
         }
 6462  0 
         catch (RecognitionException re) {
 6463  0 
             reportError(re);
 6464  0 
             recover(input,re);
 6465  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6466   
 
 6467   
         }
 6468   
 
 6469  0 
         finally {
 6470   
                 // do for sure before leaving
 6471  0 
         }
 6472  0 
         return retval;
 6473   
     }
 6474   
     // $ANTLR end "move"
 6475   
 
 6476   
 
 6477  0 
     public static class copy_return extends ParserRuleReturnScope {
 6478   
         Object tree;
 6479  0 
         public Object getTree() { return tree; }
 6480   
     };
 6481   
 
 6482   
 
 6483   
     // $ANTLR start "copy"
 6484   
     // com\\googlecode\\sparkleg\\Sparql.g:216:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6485   
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6486  0 
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6487  0 
         retval.start = input.LT(1);
 6488   
 
 6489   
 
 6490  0 
         Object root_0 = null;
 6491   
 
 6492  0 
         Token COPY140=null;
 6493  0 
         Token SILENT141=null;
 6494  0 
         Token TO142=null;
 6495  0 
         SparqlParser.graphOrDefault_return from =null;
 6496   
 
 6497  0 
         SparqlParser.graphOrDefault_return to =null;
 6498   
 
 6499   
 
 6500  0 
         Object COPY140_tree=null;
 6501  0 
         Object SILENT141_tree=null;
 6502  0 
         Object TO142_tree=null;
 6503  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6504  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6505  0 
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6506  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6507   
         try {
 6508   
             // com\\googlecode\\sparkleg\\Sparql.g:217:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6509   
             // com\\googlecode\\sparkleg\\Sparql.g:217:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6510   
             {
 6511  0 
             COPY140=(Token)match(input,COPY,FOLLOW_COPY_in_copy1692);
 6512  0 
             stream_COPY.add(COPY140);
 6513   
 
 6514   
 
 6515   
             // com\\googlecode\\sparkleg\\Sparql.g:217:12: ( SILENT )?
 6516  0 
             int alt48=2;
 6517  0 
             switch ( input.LA(1) ) {
 6518   
                 case SILENT:
 6519   
                     {
 6520  0 
                     alt48=1;
 6521   
                     }
 6522   
                     break;
 6523   
             }
 6524   
 
 6525  0 
             switch (alt48) {
 6526   
                 case 1 :
 6527   
                     // com\\googlecode\\sparkleg\\Sparql.g:217:12: SILENT
 6528   
                     {
 6529  0 
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1694);
 6530  0 
                     stream_SILENT.add(SILENT141);
 6531   
 
 6532   
 
 6533   
                     }
 6534   
                     break;
 6535   
 
 6536   
             }
 6537   
 
 6538   
 
 6539  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1699);
 6540  0 
             from=graphOrDefault();
 6541   
 
 6542  0 
             state._fsp--;
 6543   
 
 6544  0 
             stream_graphOrDefault.add(from.getTree());
 6545   
 
 6546  0 
             TO142=(Token)match(input,TO,FOLLOW_TO_in_copy1701);
 6547  0 
             stream_TO.add(TO142);
 6548   
 
 6549   
 
 6550  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1705);
 6551  0 
             to=graphOrDefault();
 6552   
 
 6553  0 
             state._fsp--;
 6554   
 
 6555  0 
             stream_graphOrDefault.add(to.getTree());
 6556   
 
 6557   
             // AST REWRITE
 6558   
             // elements: SILENT, to, from, COPY
 6559   
             // token labels:
 6560   
             // rule labels: to, retval, from
 6561   
             // token list labels:
 6562   
             // rule list labels:
 6563   
             // wildcard labels:
 6564  0 
             retval.tree = root_0;
 6565  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6566  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6567  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6568   
 
 6569  0 
             root_0 = (Object)adaptor.nil();
 6570   
             // 217:61: -> ^( COPY ( SILENT )* $from $to)
 6571   
             {
 6572   
                 // com\\googlecode\\sparkleg\\Sparql.g:217:64: ^( COPY ( SILENT )* $from $to)
 6573   
                 {
 6574  0 
                 Object root_1 = (Object)adaptor.nil();
 6575  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6576   
                 stream_COPY.nextNode()
 6577   
                 , root_1);
 6578   
 
 6579   
                 // com\\googlecode\\sparkleg\\Sparql.g:217:71: ( SILENT )*
 6580  0 
                 while ( stream_SILENT.hasNext() ) {
 6581  0 
                     adaptor.addChild(root_1,
 6582   
                     stream_SILENT.nextNode()
 6583   
                     );
 6584   
 
 6585   
                 }
 6586  0 
                 stream_SILENT.reset();
 6587   
 
 6588  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6589   
 
 6590  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6591   
 
 6592  0 
                 adaptor.addChild(root_0, root_1);
 6593   
                 }
 6594   
 
 6595   
             }
 6596   
 
 6597   
 
 6598  0 
             retval.tree = root_0;
 6599   
 
 6600   
             }
 6601   
 
 6602  0 
             retval.stop = input.LT(-1);
 6603   
 
 6604   
 
 6605  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6606  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6607   
 
 6608   
         }
 6609  0 
         catch (RecognitionException re) {
 6610  0 
             reportError(re);
 6611  0 
             recover(input,re);
 6612  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6613   
 
 6614   
         }
 6615   
 
 6616  0 
         finally {
 6617   
                 // do for sure before leaving
 6618  0 
         }
 6619  0 
         return retval;
 6620   
     }
 6621   
     // $ANTLR end "copy"
 6622   
 
 6623   
 
 6624  8 
     public static class insert_return extends ParserRuleReturnScope {
 6625   
         Object tree;
 6626  8 
         public Object getTree() { return tree; }
 6627   
     };
 6628   
 
 6629   
 
 6630   
     // $ANTLR start "insert"
 6631   
     // com\\googlecode\\sparkleg\\Sparql.g:220:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6632   
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6633  8 
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6634  8 
         retval.start = input.LT(1);
 6635   
 
 6636   
 
 6637  8 
         Object root_0 = null;
 6638   
 
 6639  8 
         Token INSERT143=null;
 6640  8 
         Token DATA144=null;
 6641  8 
         SparqlParser.quadPattern_return quadPattern145 =null;
 6642   
 
 6643   
 
 6644  8 
         Object INSERT143_tree=null;
 6645  8 
         Object DATA144_tree=null;
 6646  8 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6647  8 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6648  8 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6649   
         try {
 6650   
             // com\\googlecode\\sparkleg\\Sparql.g:221:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6651   
             // com\\googlecode\\sparkleg\\Sparql.g:221:7: INSERT DATA quadPattern
 6652   
             {
 6653  8 
             INSERT143=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1737);
 6654  8 
             stream_INSERT.add(INSERT143);
 6655   
 
 6656   
 
 6657  8 
             DATA144=(Token)match(input,DATA,FOLLOW_DATA_in_insert1739);
 6658  8 
             stream_DATA.add(DATA144);
 6659   
 
 6660   
 
 6661  8 
             pushFollow(FOLLOW_quadPattern_in_insert1741);
 6662  8 
             quadPattern145=quadPattern();
 6663   
 
 6664  8 
             state._fsp--;
 6665   
 
 6666  8 
             stream_quadPattern.add(quadPattern145.getTree());
 6667   
 
 6668   
             // AST REWRITE
 6669   
             // elements: DATA, INSERT, quadPattern
 6670   
             // token labels:
 6671   
             // rule labels: retval
 6672   
             // token list labels:
 6673   
             // rule list labels:
 6674   
             // wildcard labels:
 6675  8 
             retval.tree = root_0;
 6676  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6677   
 
 6678  8 
             root_0 = (Object)adaptor.nil();
 6679   
             // 221:31: -> ^( INSERT DATA quadPattern )
 6680   
             {
 6681   
                 // com\\googlecode\\sparkleg\\Sparql.g:221:34: ^( INSERT DATA quadPattern )
 6682   
                 {
 6683  8 
                 Object root_1 = (Object)adaptor.nil();
 6684  8 
                 root_1 = (Object)adaptor.becomeRoot(
 6685   
                 stream_INSERT.nextNode()
 6686   
                 , root_1);
 6687   
 
 6688  8 
                 adaptor.addChild(root_1,
 6689   
                 stream_DATA.nextNode()
 6690   
                 );
 6691   
 
 6692  8 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6693   
 
 6694  8 
                 adaptor.addChild(root_0, root_1);
 6695   
                 }
 6696   
 
 6697   
             }
 6698   
 
 6699   
 
 6700  8 
             retval.tree = root_0;
 6701   
 
 6702   
             }
 6703   
 
 6704  8 
             retval.stop = input.LT(-1);
 6705   
 
 6706   
 
 6707  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6708  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6709   
 
 6710   
         }
 6711  0 
         catch (RecognitionException re) {
 6712  0 
             reportError(re);
 6713  0 
             recover(input,re);
 6714  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6715   
 
 6716   
         }
 6717   
 
 6718  0 
         finally {
 6719   
                 // do for sure before leaving
 6720  8 
         }
 6721  8 
         return retval;
 6722   
     }
 6723   
     // $ANTLR end "insert"
 6724   
 
 6725   
 
 6726  24 
     public static class delete_return extends ParserRuleReturnScope {
 6727   
         Object tree;
 6728  24 
         public Object getTree() { return tree; }
 6729   
     };
 6730   
 
 6731   
 
 6732   
     // $ANTLR start "delete"
 6733   
     // com\\googlecode\\sparkleg\\Sparql.g:224:1: delete : DELETE ( deleteData | deleteWhere ) ;
 6734   
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6735  24 
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6736  24 
         retval.start = input.LT(1);
 6737   
 
 6738   
 
 6739  24 
         Object root_0 = null;
 6740   
 
 6741  24 
         Token DELETE146=null;
 6742  24 
         SparqlParser.deleteData_return deleteData147 =null;
 6743   
 
 6744  24 
         SparqlParser.deleteWhere_return deleteWhere148 =null;
 6745   
 
 6746   
 
 6747  24 
         Object DELETE146_tree=null;
 6748   
 
 6749   
         try {
 6750   
             // com\\googlecode\\sparkleg\\Sparql.g:225:5: ( DELETE ( deleteData | deleteWhere ) )
 6751   
             // com\\googlecode\\sparkleg\\Sparql.g:225:7: DELETE ( deleteData | deleteWhere )
 6752   
             {
 6753  24 
             root_0 = (Object)adaptor.nil();
 6754   
 
 6755   
 
 6756  24 
             DELETE146=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1775);
 6757  24 
             DELETE146_tree =
 6758   
             (Object)adaptor.create(DELETE146)
 6759   
             ;
 6760  24 
             adaptor.addChild(root_0, DELETE146_tree);
 6761   
 
 6762   
 
 6763   
             // com\\googlecode\\sparkleg\\Sparql.g:225:14: ( deleteData | deleteWhere )
 6764  24 
             int alt49=2;
 6765  24 
             switch ( input.LA(1) ) {
 6766   
             case DATA:
 6767   
                 {
 6768  12 
                 alt49=1;
 6769   
                 }
 6770  12 
                 break;
 6771   
             case WHERE:
 6772   
                 {
 6773  12 
                 alt49=2;
 6774   
                 }
 6775  12 
                 break;
 6776   
             default:
 6777  0 
                 NoViableAltException nvae =
 6778   
                     new NoViableAltException("", 49, 0, input);
 6779   
 
 6780  0 
                 throw nvae;
 6781   
 
 6782   
             }
 6783   
 
 6784  24 
             switch (alt49) {
 6785   
                 case 1 :
 6786   
                     // com\\googlecode\\sparkleg\\Sparql.g:225:15: deleteData
 6787   
                     {
 6788  12 
                     pushFollow(FOLLOW_deleteData_in_delete1778);
 6789  12 
                     deleteData147=deleteData();
 6790   
 
 6791  12 
                     state._fsp--;
 6792   
 
 6793  12 
                     adaptor.addChild(root_0, deleteData147.getTree());
 6794   
 
 6795   
                     }
 6796  12 
                     break;
 6797   
                 case 2 :
 6798   
                     // com\\googlecode\\sparkleg\\Sparql.g:225:28: deleteWhere
 6799   
                     {
 6800  12 
                     pushFollow(FOLLOW_deleteWhere_in_delete1782);
 6801  12 
                     deleteWhere148=deleteWhere();
 6802   
 
 6803  12 
                     state._fsp--;
 6804   
 
 6805  12 
                     adaptor.addChild(root_0, deleteWhere148.getTree());
 6806   
 
 6807   
                     }
 6808   
                     break;
 6809   
 
 6810   
             }
 6811   
 
 6812   
 
 6813   
             }
 6814   
 
 6815  24 
             retval.stop = input.LT(-1);
 6816   
 
 6817   
 
 6818  24 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6819  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6820   
 
 6821   
         }
 6822  0 
         catch (RecognitionException re) {
 6823  0 
             reportError(re);
 6824  0 
             recover(input,re);
 6825  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6826   
 
 6827   
         }
 6828   
 
 6829  0 
         finally {
 6830   
                 // do for sure before leaving
 6831  24 
         }
 6832  24 
         return retval;
 6833   
     }
 6834   
     // $ANTLR end "delete"
 6835   
 
 6836   
 
 6837  12 
     public static class deleteData_return extends ParserRuleReturnScope {
 6838   
         Object tree;
 6839  12 
         public Object getTree() { return tree; }
 6840   
     };
 6841   
 
 6842   
 
 6843   
     // $ANTLR start "deleteData"
 6844   
     // com\\googlecode\\sparkleg\\Sparql.g:228:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6845   
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6846  12 
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6847  12 
         retval.start = input.LT(1);
 6848   
 
 6849   
 
 6850  12 
         Object root_0 = null;
 6851   
 
 6852  12 
         Token DATA149=null;
 6853  12 
         SparqlParser.quadPattern_return quadPattern150 =null;
 6854   
 
 6855   
 
 6856  12 
         Object DATA149_tree=null;
 6857  12 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6858  12 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6859   
         try {
 6860   
             // com\\googlecode\\sparkleg\\Sparql.g:229:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6861   
             // com\\googlecode\\sparkleg\\Sparql.g:229:7: DATA quadPattern
 6862   
             {
 6863  12 
             DATA149=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1800);
 6864  12 
             stream_DATA.add(DATA149);
 6865   
 
 6866   
 
 6867  12 
             pushFollow(FOLLOW_quadPattern_in_deleteData1802);
 6868  12 
             quadPattern150=quadPattern();
 6869   
 
 6870  12 
             state._fsp--;
 6871   
 
 6872  12 
             stream_quadPattern.add(quadPattern150.getTree());
 6873   
 
 6874   
             // AST REWRITE
 6875   
             // elements: quadPattern, DATA
 6876   
             // token labels:
 6877   
             // rule labels: retval
 6878   
             // token list labels:
 6879   
             // rule list labels:
 6880   
             // wildcard labels:
 6881  12 
             retval.tree = root_0;
 6882  12 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6883   
 
 6884  12 
             root_0 = (Object)adaptor.nil();
 6885   
             // 229:24: -> ^( DELETE DATA quadPattern )
 6886   
             {
 6887   
                 // com\\googlecode\\sparkleg\\Sparql.g:229:27: ^( DELETE DATA quadPattern )
 6888   
                 {
 6889  12 
                 Object root_1 = (Object)adaptor.nil();
 6890  12 
                 root_1 = (Object)adaptor.becomeRoot(
 6891   
                 (Object)adaptor.create(DELETE, "DELETE")
 6892   
                 , root_1);
 6893   
 
 6894  12 
                 adaptor.addChild(root_1,
 6895   
                 stream_DATA.nextNode()
 6896   
                 );
 6897   
 
 6898  12 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6899   
 
 6900  12 
                 adaptor.addChild(root_0, root_1);
 6901   
                 }
 6902   
 
 6903   
             }
 6904   
 
 6905   
 
 6906  12 
             retval.tree = root_0;
 6907   
 
 6908   
             }
 6909   
 
 6910  12 
             retval.stop = input.LT(-1);
 6911   
 
 6912   
 
 6913  12 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6914  12 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6915   
 
 6916   
         }
 6917  0 
         catch (RecognitionException re) {
 6918  0 
             reportError(re);
 6919  0 
             recover(input,re);
 6920  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6921   
 
 6922   
         }
 6923   
 
 6924  0 
         finally {
 6925   
                 // do for sure before leaving
 6926  12 
         }
 6927  12 
         return retval;
 6928   
     }
 6929   
     // $ANTLR end "deleteData"
 6930   
 
 6931   
 
 6932  12 
     public static class deleteWhere_return extends ParserRuleReturnScope {
 6933   
         Object tree;
 6934  12 
         public Object getTree() { return tree; }
 6935   
     };
 6936   
 
 6937   
 
 6938   
     // $ANTLR start "deleteWhere"
 6939   
     // com\\googlecode\\sparkleg\\Sparql.g:232:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 6940   
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 6941  12 
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 6942  12 
         retval.start = input.LT(1);
 6943   
 
 6944   
 
 6945  12 
         Object root_0 = null;
 6946   
 
 6947  12 
         Token WHERE151=null;
 6948  12 
         SparqlParser.quadPattern_return quadPattern152 =null;
 6949   
 
 6950   
 
 6951  12 
         Object WHERE151_tree=null;
 6952  12 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 6953  12 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6954   
         try {
 6955   
             // com\\googlecode\\sparkleg\\Sparql.g:233:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 6956   
             // com\\googlecode\\sparkleg\\Sparql.g:233:7: WHERE quadPattern
 6957   
             {
 6958  12 
             WHERE151=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1829);
 6959  12 
             stream_WHERE.add(WHERE151);
 6960   
 
 6961   
 
 6962  12 
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1831);
 6963  12 
             quadPattern152=quadPattern();
 6964   
 
 6965  12 
             state._fsp--;
 6966   
 
 6967  12 
             stream_quadPattern.add(quadPattern152.getTree());
 6968   
 
 6969   
             // AST REWRITE
 6970   
             // elements: WHERE, quadPattern
 6971   
             // token labels:
 6972   
             // rule labels: retval
 6973   
             // token list labels:
 6974   
             // rule list labels:
 6975   
             // wildcard labels:
 6976  12 
             retval.tree = root_0;
 6977  12 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6978   
 
 6979  12 
             root_0 = (Object)adaptor.nil();
 6980   
             // 233:25: -> ^( DELETE WHERE quadPattern )
 6981   
             {
 6982   
                 // com\\googlecode\\sparkleg\\Sparql.g:233:28: ^( DELETE WHERE quadPattern )
 6983   
                 {
 6984  12 
                 Object root_1 = (Object)adaptor.nil();
 6985  12 
                 root_1 = (Object)adaptor.becomeRoot(
 6986   
                 (Object)adaptor.create(DELETE, "DELETE")
 6987   
                 , root_1);
 6988   
 
 6989  12 
                 adaptor.addChild(root_1,
 6990   
                 stream_WHERE.nextNode()
 6991   
                 );
 6992   
 
 6993  12 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6994   
 
 6995  12 
                 adaptor.addChild(root_0, root_1);
 6996   
                 }
 6997   
 
 6998   
             }
 6999   
 
 7000   
 
 7001  12 
             retval.tree = root_0;
 7002   
 
 7003   
             }
 7004   
 
 7005  12 
             retval.stop = input.LT(-1);
 7006   
 
 7007   
 
 7008  12 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7009  12 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7010   
 
 7011   
         }
 7012  0 
         catch (RecognitionException re) {
 7013  0 
             reportError(re);
 7014  0 
             recover(input,re);
 7015  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7016   
 
 7017   
         }
 7018   
 
 7019  0 
         finally {
 7020   
                 // do for sure before leaving
 7021  12 
         }
 7022  12 
         return retval;
 7023   
     }
 7024   
     // $ANTLR end "deleteWhere"
 7025   
 
 7026   
 
 7027  80 
     public static class modify_return extends ParserRuleReturnScope {
 7028   
         Object tree;
 7029  80 
         public Object getTree() { return tree; }
 7030   
     };
 7031   
 
 7032   
 
 7033   
     // $ANTLR start "modify"
 7034   
     // com\\googlecode\\sparkleg\\Sparql.g:236:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7035   
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7036  80 
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7037  80 
         retval.start = input.LT(1);
 7038   
 
 7039   
 
 7040  80 
         Object root_0 = null;
 7041   
 
 7042  80 
         Token WITH153=null;
 7043  80 
         Token WHERE159=null;
 7044  80 
         SparqlParser.iriRef_return iriRef154 =null;
 7045   
 
 7046  80 
         SparqlParser.deleteClause_return deleteClause155 =null;
 7047   
 
 7048  80 
         SparqlParser.insertClause_return insertClause156 =null;
 7049   
 
 7050  80 
         SparqlParser.insertClause_return insertClause157 =null;
 7051   
 
 7052  80 
         SparqlParser.usingClause_return usingClause158 =null;
 7053   
 
 7054  80 
         SparqlParser.groupGraphPattern_return groupGraphPattern160 =null;
 7055   
 
 7056   
 
 7057  80 
         Object WITH153_tree=null;
 7058  80 
         Object WHERE159_tree=null;
 7059  80 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7060  80 
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7061  80 
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7062  80 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7063  80 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7064  80 
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7065  80 
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7066   
         try {
 7067   
             // com\\googlecode\\sparkleg\\Sparql.g:237:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7068   
             // com\\googlecode\\sparkleg\\Sparql.g:237:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7069   
             {
 7070   
             // com\\googlecode\\sparkleg\\Sparql.g:237:7: ( WITH iriRef )?
 7071  80 
             int alt50=2;
 7072  80 
             switch ( input.LA(1) ) {
 7073   
                 case WITH:
 7074   
                     {
 7075  14 
                     alt50=1;
 7076   
                     }
 7077   
                     break;
 7078   
             }
 7079   
 
 7080  80 
             switch (alt50) {
 7081   
                 case 1 :
 7082   
                     // com\\googlecode\\sparkleg\\Sparql.g:237:8: WITH iriRef
 7083   
                     {
 7084  14 
                     WITH153=(Token)match(input,WITH,FOLLOW_WITH_in_modify1863);
 7085  14 
                     stream_WITH.add(WITH153);
 7086   
 
 7087   
 
 7088  14 
                     pushFollow(FOLLOW_iriRef_in_modify1865);
 7089  14 
                     iriRef154=iriRef();
 7090   
 
 7091  14 
                     state._fsp--;
 7092   
 
 7093  14 
                     stream_iriRef.add(iriRef154.getTree());
 7094   
 
 7095   
                     }
 7096   
                     break;
 7097   
 
 7098   
             }
 7099   
 
 7100   
 
 7101   
             // com\\googlecode\\sparkleg\\Sparql.g:237:22: ( deleteClause ( insertClause )? | insertClause )
 7102  80 
             int alt52=2;
 7103  80 
             switch ( input.LA(1) ) {
 7104   
             case DELETE:
 7105   
                 {
 7106  66 
                 alt52=1;
 7107   
                 }
 7108  66 
                 break;
 7109   
             case INSERT:
 7110   
                 {
 7111  14 
                 alt52=2;
 7112   
                 }
 7113  14 
                 break;
 7114   
             default:
 7115  0 
                 NoViableAltException nvae =
 7116   
                     new NoViableAltException("", 52, 0, input);
 7117   
 
 7118  0 
                 throw nvae;
 7119   
 
 7120   
             }
 7121   
 
 7122  80 
             switch (alt52) {
 7123   
                 case 1 :
 7124   
                     // com\\googlecode\\sparkleg\\Sparql.g:237:23: deleteClause ( insertClause )?
 7125   
                     {
 7126  66 
                     pushFollow(FOLLOW_deleteClause_in_modify1870);
 7127  66 
                     deleteClause155=deleteClause();
 7128   
 
 7129  66 
                     state._fsp--;
 7130   
 
 7131  66 
                     stream_deleteClause.add(deleteClause155.getTree());
 7132   
 
 7133   
                     // com\\googlecode\\sparkleg\\Sparql.g:237:36: ( insertClause )?
 7134  66 
                     int alt51=2;
 7135  66 
                     switch ( input.LA(1) ) {
 7136   
                         case INSERT:
 7137   
                             {
 7138  10 
                             alt51=1;
 7139   
                             }
 7140   
                             break;
 7141   
                     }
 7142   
 
 7143  66 
                     switch (alt51) {
 7144   
                         case 1 :
 7145   
                             // com\\googlecode\\sparkleg\\Sparql.g:237:36: insertClause
 7146   
                             {
 7147  10 
                             pushFollow(FOLLOW_insertClause_in_modify1872);
 7148  10 
                             insertClause156=insertClause();
 7149   
 
 7150  10 
                             state._fsp--;
 7151   
 
 7152  10 
                             stream_insertClause.add(insertClause156.getTree());
 7153   
 
 7154   
                             }
 7155   
                             break;
 7156   
 
 7157   
                     }
 7158   
 
 7159   
 
 7160   
                     }
 7161  66 
                     break;
 7162   
                 case 2 :
 7163   
                     // com\\googlecode\\sparkleg\\Sparql.g:237:52: insertClause
 7164   
                     {
 7165  14 
                     pushFollow(FOLLOW_insertClause_in_modify1877);
 7166  14 
                     insertClause157=insertClause();
 7167   
 
 7168  14 
                     state._fsp--;
 7169   
 
 7170  14 
                     stream_insertClause.add(insertClause157.getTree());
 7171   
 
 7172   
                     }
 7173   
                     break;
 7174   
 
 7175   
             }
 7176   
 
 7177   
 
 7178   
             // com\\googlecode\\sparkleg\\Sparql.g:237:66: ( usingClause )*
 7179   
             loop53:
 7180   
             do {
 7181  98 
                 int alt53=2;
 7182  98 
                 switch ( input.LA(1) ) {
 7183   
                 case USING:
 7184   
                     {
 7185  18 
                     alt53=1;
 7186   
                     }
 7187   
                     break;
 7188   
 
 7189   
                 }
 7190   
 
 7191  98 
                 switch (alt53) {
 7192   
                     case 1 :
 7193   
                         // com\\googlecode\\sparkleg\\Sparql.g:237:66: usingClause
 7194   
                         {
 7195  18 
                         pushFollow(FOLLOW_usingClause_in_modify1880);
 7196  18 
                         usingClause158=usingClause();
 7197   
 
 7198  18 
                         state._fsp--;
 7199   
 
 7200  18 
                         stream_usingClause.add(usingClause158.getTree());
 7201   
 
 7202   
                         }
 7203  18 
                         break;
 7204   
 
 7205   
                     default :
 7206  80 
                         break loop53;
 7207   
                 }
 7208  18 
             } while (true);
 7209   
 
 7210   
 
 7211  80 
             WHERE159=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify1883);
 7212  80 
             stream_WHERE.add(WHERE159);
 7213   
 
 7214   
 
 7215  80 
             pushFollow(FOLLOW_groupGraphPattern_in_modify1885);
 7216  80 
             groupGraphPattern160=groupGraphPattern();
 7217   
 
 7218  80 
             state._fsp--;
 7219   
 
 7220  80 
             stream_groupGraphPattern.add(groupGraphPattern160.getTree());
 7221   
 
 7222   
             // AST REWRITE
 7223   
             // elements: usingClause, iriRef, WITH, groupGraphPattern, insertClause, deleteClause
 7224   
             // token labels:
 7225   
             // rule labels: retval
 7226   
             // token list labels:
 7227   
             // rule list labels:
 7228   
             // wildcard labels:
 7229  80 
             retval.tree = root_0;
 7230  80 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7231   
 
 7232  80 
             root_0 = (Object)adaptor.nil();
 7233   
             // 237:103: -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7234   
             {
 7235   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:106: ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7236   
                 {
 7237  80 
                 Object root_1 = (Object)adaptor.nil();
 7238  80 
                 root_1 = (Object)adaptor.becomeRoot(
 7239   
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7240   
                 , root_1);
 7241   
 
 7242   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:115: ( ^( WITH iriRef ) )?
 7243  80 
                 if ( stream_iriRef.hasNext()||stream_WITH.hasNext() ) {
 7244   
                     // com\\googlecode\\sparkleg\\Sparql.g:237:115: ^( WITH iriRef )
 7245   
                     {
 7246  14 
                     Object root_2 = (Object)adaptor.nil();
 7247  14 
                     root_2 = (Object)adaptor.becomeRoot(
 7248   
                     stream_WITH.nextNode()
 7249   
                     , root_2);
 7250   
 
 7251  14 
                     adaptor.addChild(root_2, stream_iriRef.nextTree());
 7252   
 
 7253  14 
                     adaptor.addChild(root_1, root_2);
 7254   
                     }
 7255   
 
 7256   
                 }
 7257  80 
                 stream_iriRef.reset();
 7258  80 
                 stream_WITH.reset();
 7259   
 
 7260   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:131: ( deleteClause )*
 7261  146 
                 while ( stream_deleteClause.hasNext() ) {
 7262  66 
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7263   
 
 7264   
                 }
 7265  80 
                 stream_deleteClause.reset();
 7266   
 
 7267   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:145: ( insertClause )*
 7268  104 
                 while ( stream_insertClause.hasNext() ) {
 7269  24 
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7270   
 
 7271   
                 }
 7272  80 
                 stream_insertClause.reset();
 7273   
 
 7274   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:159: ( usingClause )*
 7275  98 
                 while ( stream_usingClause.hasNext() ) {
 7276  18 
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7277   
 
 7278   
                 }
 7279  80 
                 stream_usingClause.reset();
 7280   
 
 7281   
                 // com\\googlecode\\sparkleg\\Sparql.g:237:172: ^( WHERE_CLAUSE groupGraphPattern )
 7282   
                 {
 7283  80 
                 Object root_2 = (Object)adaptor.nil();
 7284  80 
                 root_2 = (Object)adaptor.becomeRoot(
 7285   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7286   
                 , root_2);
 7287   
 
 7288  80 
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7289   
 
 7290  80 
                 adaptor.addChild(root_1, root_2);
 7291   
                 }
 7292   
 
 7293  80 
                 adaptor.addChild(root_0, root_1);
 7294   
                 }
 7295   
 
 7296   
             }
 7297   
 
 7298   
 
 7299  80 
             retval.tree = root_0;
 7300   
 
 7301   
             }
 7302   
 
 7303  80 
             retval.stop = input.LT(-1);
 7304   
 
 7305   
 
 7306  80 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7307  80 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7308   
 
 7309   
         }
 7310  0 
         catch (RecognitionException re) {
 7311  0 
             reportError(re);
 7312  0 
             recover(input,re);
 7313  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7314   
 
 7315   
         }
 7316   
 
 7317  0 
         finally {
 7318   
                 // do for sure before leaving
 7319  80 
         }
 7320  80 
         return retval;
 7321   
     }
 7322   
     // $ANTLR end "modify"
 7323   
 
 7324   
 
 7325  66 
     public static class deleteClause_return extends ParserRuleReturnScope {
 7326   
         Object tree;
 7327  66 
         public Object getTree() { return tree; }
 7328   
     };
 7329   
 
 7330   
 
 7331   
     // $ANTLR start "deleteClause"
 7332   
     // com\\googlecode\\sparkleg\\Sparql.g:240:1: deleteClause : DELETE quadPattern -> DELETE quadPattern ;
 7333   
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7334  66 
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7335  66 
         retval.start = input.LT(1);
 7336   
 
 7337   
 
 7338  66 
         Object root_0 = null;
 7339   
 
 7340  66 
         Token DELETE161=null;
 7341  66 
         SparqlParser.quadPattern_return quadPattern162 =null;
 7342   
 
 7343   
 
 7344  66 
         Object DELETE161_tree=null;
 7345  66 
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7346  66 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7347   
         try {
 7348   
             // com\\googlecode\\sparkleg\\Sparql.g:241:5: ( DELETE quadPattern -> DELETE quadPattern )
 7349   
             // com\\googlecode\\sparkleg\\Sparql.g:241:7: DELETE quadPattern
 7350   
             {
 7351  66 
             DELETE161=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause1932);
 7352  66 
             stream_DELETE.add(DELETE161);
 7353   
 
 7354   
 
 7355  66 
             pushFollow(FOLLOW_quadPattern_in_deleteClause1934);
 7356  66 
             quadPattern162=quadPattern();
 7357   
 
 7358  66 
             state._fsp--;
 7359   
 
 7360  66 
             stream_quadPattern.add(quadPattern162.getTree());
 7361   
 
 7362   
             // AST REWRITE
 7363   
             // elements: DELETE, quadPattern
 7364   
             // token labels:
 7365   
             // rule labels: retval
 7366   
             // token list labels:
 7367   
             // rule list labels:
 7368   
             // wildcard labels:
 7369  66 
             retval.tree = root_0;
 7370  66 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7371   
 
 7372  66 
             root_0 = (Object)adaptor.nil();
 7373   
             // 241:26: -> DELETE quadPattern
 7374   
             {
 7375  66 
                 adaptor.addChild(root_0,
 7376   
                 stream_DELETE.nextNode()
 7377   
                 );
 7378   
 
 7379  66 
                 adaptor.addChild(root_0, stream_quadPattern.nextTree());
 7380   
 
 7381   
             }
 7382   
 
 7383   
 
 7384  66 
             retval.tree = root_0;
 7385   
 
 7386   
             }
 7387   
 
 7388  66 
             retval.stop = input.LT(-1);
 7389   
 
 7390   
 
 7391  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7392  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7393   
 
 7394   
         }
 7395  0 
         catch (RecognitionException re) {
 7396  0 
             reportError(re);
 7397  0 
             recover(input,re);
 7398  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7399   
 
 7400   
         }
 7401   
 
 7402  0 
         finally {
 7403   
                 // do for sure before leaving
 7404  66 
         }
 7405  66 
         return retval;
 7406   
     }
 7407   
     // $ANTLR end "deleteClause"
 7408   
 
 7409   
 
 7410  24 
     public static class insertClause_return extends ParserRuleReturnScope {
 7411   
         Object tree;
 7412  24 
         public Object getTree() { return tree; }
 7413   
     };
 7414   
 
 7415   
 
 7416   
     // $ANTLR start "insertClause"
 7417   
     // com\\googlecode\\sparkleg\\Sparql.g:244:1: insertClause : INSERT quadPattern -> INSERT quadPattern ;
 7418   
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7419  24 
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7420  24 
         retval.start = input.LT(1);
 7421   
 
 7422   
 
 7423  24 
         Object root_0 = null;
 7424   
 
 7425  24 
         Token INSERT163=null;
 7426  24 
         SparqlParser.quadPattern_return quadPattern164 =null;
 7427   
 
 7428   
 
 7429  24 
         Object INSERT163_tree=null;
 7430  24 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7431  24 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7432   
         try {
 7433   
             // com\\googlecode\\sparkleg\\Sparql.g:245:5: ( INSERT quadPattern -> INSERT quadPattern )
 7434   
             // com\\googlecode\\sparkleg\\Sparql.g:245:7: INSERT quadPattern
 7435   
             {
 7436  24 
             INSERT163=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause1963);
 7437  24 
             stream_INSERT.add(INSERT163);
 7438   
 
 7439   
 
 7440  24 
             pushFollow(FOLLOW_quadPattern_in_insertClause1965);
 7441  24 
             quadPattern164=quadPattern();
 7442   
 
 7443  24 
             state._fsp--;
 7444   
 
 7445  24 
             stream_quadPattern.add(quadPattern164.getTree());
 7446   
 
 7447   
             // AST REWRITE
 7448   
             // elements: quadPattern, INSERT
 7449   
             // token labels:
 7450   
             // rule labels: retval
 7451   
             // token list labels:
 7452   
             // rule list labels:
 7453   
             // wildcard labels:
 7454  24 
             retval.tree = root_0;
 7455  24 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7456   
 
 7457  24 
             root_0 = (Object)adaptor.nil();
 7458   
             // 245:26: -> INSERT quadPattern
 7459   
             {
 7460  24 
                 adaptor.addChild(root_0,
 7461   
                 stream_INSERT.nextNode()
 7462   
                 );
 7463   
 
 7464  24 
                 adaptor.addChild(root_0, stream_quadPattern.nextTree());
 7465   
 
 7466   
             }
 7467   
 
 7468   
 
 7469  24 
             retval.tree = root_0;
 7470   
 
 7471   
             }
 7472   
 
 7473  24 
             retval.stop = input.LT(-1);
 7474   
 
 7475   
 
 7476  24 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7477  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7478   
 
 7479   
         }
 7480  0 
         catch (RecognitionException re) {
 7481  0 
             reportError(re);
 7482  0 
             recover(input,re);
 7483  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7484   
 
 7485   
         }
 7486   
 
 7487  0 
         finally {
 7488   
                 // do for sure before leaving
 7489  24 
         }
 7490  24 
         return retval;
 7491   
     }
 7492   
     // $ANTLR end "insertClause"
 7493   
 
 7494   
 
 7495  18 
     public static class usingClause_return extends ParserRuleReturnScope {
 7496   
         Object tree;
 7497  18 
         public Object getTree() { return tree; }
 7498   
     };
 7499   
 
 7500   
 
 7501   
     // $ANTLR start "usingClause"
 7502   
     // com\\googlecode\\sparkleg\\Sparql.g:248:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7503   
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7504  18 
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7505  18 
         retval.start = input.LT(1);
 7506   
 
 7507   
 
 7508  18 
         Object root_0 = null;
 7509   
 
 7510  18 
         Token USING165=null;
 7511  18 
         Token NAMED166=null;
 7512  18 
         SparqlParser.iriRef_return iriRef167 =null;
 7513   
 
 7514   
 
 7515  18 
         Object USING165_tree=null;
 7516  18 
         Object NAMED166_tree=null;
 7517  18 
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7518  18 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7519  18 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7520   
         try {
 7521   
             // com\\googlecode\\sparkleg\\Sparql.g:249:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7522   
             // com\\googlecode\\sparkleg\\Sparql.g:249:7: USING ( NAMED )? iriRef
 7523   
             {
 7524  18 
             USING165=(Token)match(input,USING,FOLLOW_USING_in_usingClause1988);
 7525  18 
             stream_USING.add(USING165);
 7526   
 
 7527   
 
 7528   
             // com\\googlecode\\sparkleg\\Sparql.g:249:13: ( NAMED )?
 7529  18 
             int alt54=2;
 7530  18 
             switch ( input.LA(1) ) {
 7531   
                 case NAMED:
 7532   
                     {
 7533  0 
                     alt54=1;
 7534   
                     }
 7535   
                     break;
 7536   
             }
 7537   
 
 7538  18 
             switch (alt54) {
 7539   
                 case 1 :
 7540   
                     // com\\googlecode\\sparkleg\\Sparql.g:249:13: NAMED
 7541   
                     {
 7542  0 
                     NAMED166=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause1990);
 7543  0 
                     stream_NAMED.add(NAMED166);
 7544   
 
 7545   
 
 7546   
                     }
 7547   
                     break;
 7548   
 
 7549   
             }
 7550   
 
 7551   
 
 7552  18 
             pushFollow(FOLLOW_iriRef_in_usingClause1993);
 7553  18 
             iriRef167=iriRef();
 7554   
 
 7555  18 
             state._fsp--;
 7556   
 
 7557  18 
             stream_iriRef.add(iriRef167.getTree());
 7558   
 
 7559   
             // AST REWRITE
 7560   
             // elements: USING, iriRef, NAMED
 7561   
             // token labels:
 7562   
             // rule labels: retval
 7563   
             // token list labels:
 7564   
             // rule list labels:
 7565   
             // wildcard labels:
 7566  18 
             retval.tree = root_0;
 7567  18 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7568   
 
 7569  18 
             root_0 = (Object)adaptor.nil();
 7570   
             // 249:27: -> ^( USING ( NAMED )? iriRef )
 7571   
             {
 7572   
                 // com\\googlecode\\sparkleg\\Sparql.g:249:30: ^( USING ( NAMED )? iriRef )
 7573   
                 {
 7574  18 
                 Object root_1 = (Object)adaptor.nil();
 7575  18 
                 root_1 = (Object)adaptor.becomeRoot(
 7576   
                 stream_USING.nextNode()
 7577   
                 , root_1);
 7578   
 
 7579   
                 // com\\googlecode\\sparkleg\\Sparql.g:249:38: ( NAMED )?
 7580  18 
                 if ( stream_NAMED.hasNext() ) {
 7581  0 
                     adaptor.addChild(root_1,
 7582   
                     stream_NAMED.nextNode()
 7583   
                     );
 7584   
 
 7585   
                 }
 7586  18 
                 stream_NAMED.reset();
 7587   
 
 7588  18 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7589   
 
 7590  18 
                 adaptor.addChild(root_0, root_1);
 7591   
                 }
 7592   
 
 7593   
             }
 7594   
 
 7595   
 
 7596  18 
             retval.tree = root_0;
 7597   
 
 7598   
             }
 7599   
 
 7600  18 
             retval.stop = input.LT(-1);
 7601   
 
 7602   
 
 7603  18 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7604  18 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7605   
 
 7606   
         }
 7607  0 
         catch (RecognitionException re) {
 7608  0 
             reportError(re);
 7609  0 
             recover(input,re);
 7610  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7611   
 
 7612   
         }
 7613   
 
 7614  0 
         finally {
 7615   
                 // do for sure before leaving
 7616  18 
         }
 7617  18 
         return retval;
 7618   
     }
 7619   
     // $ANTLR end "usingClause"
 7620   
 
 7621   
 
 7622  0 
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7623   
         Object tree;
 7624  0 
         public Object getTree() { return tree; }
 7625   
     };
 7626   
 
 7627   
 
 7628   
     // $ANTLR start "graphOrDefault"
 7629   
     // com\\googlecode\\sparkleg\\Sparql.g:252:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7630   
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7631  0 
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7632  0 
         retval.start = input.LT(1);
 7633   
 
 7634   
 
 7635  0 
         Object root_0 = null;
 7636   
 
 7637  0 
         Token DEFAULT168=null;
 7638  0 
         Token GRAPH169=null;
 7639  0 
         SparqlParser.iriRef_return iriRef170 =null;
 7640   
 
 7641   
 
 7642  0 
         Object DEFAULT168_tree=null;
 7643  0 
         Object GRAPH169_tree=null;
 7644   
 
 7645   
         try {
 7646   
             // com\\googlecode\\sparkleg\\Sparql.g:253:5: ( DEFAULT | ( GRAPH )? iriRef )
 7647  0 
             int alt56=2;
 7648  0 
             switch ( input.LA(1) ) {
 7649   
             case DEFAULT:
 7650   
                 {
 7651  0 
                 alt56=1;
 7652   
                 }
 7653  0 
                 break;
 7654   
             case GRAPH:
 7655   
             case IRI_REF:
 7656   
             case PNAME_LN:
 7657   
             case PNAME_NS:
 7658   
                 {
 7659  0 
                 alt56=2;
 7660   
                 }
 7661  0 
                 break;
 7662   
             default:
 7663  0 
                 NoViableAltException nvae =
 7664   
                     new NoViableAltException("", 56, 0, input);
 7665   
 
 7666  0 
                 throw nvae;
 7667   
 
 7668   
             }
 7669   
 
 7670  0 
             switch (alt56) {
 7671   
                 case 1 :
 7672   
                     // com\\googlecode\\sparkleg\\Sparql.g:253:7: DEFAULT
 7673   
                     {
 7674  0 
                     root_0 = (Object)adaptor.nil();
 7675   
 
 7676   
 
 7677  0 
                     DEFAULT168=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2024);
 7678  0 
                     DEFAULT168_tree =
 7679   
                     (Object)adaptor.create(DEFAULT168)
 7680   
                     ;
 7681  0 
                     adaptor.addChild(root_0, DEFAULT168_tree);
 7682   
 
 7683   
 
 7684   
                     }
 7685  0 
                     break;
 7686   
                 case 2 :
 7687   
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: ( GRAPH )? iriRef
 7688   
                     {
 7689  0 
                     root_0 = (Object)adaptor.nil();
 7690   
 
 7691   
 
 7692   
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: ( GRAPH )?
 7693  0 
                     int alt55=2;
 7694  0 
                     switch ( input.LA(1) ) {
 7695   
                         case GRAPH:
 7696   
                             {
 7697  0 
                             alt55=1;
 7698   
                             }
 7699   
                             break;
 7700   
                     }
 7701   
 
 7702  0 
                     switch (alt55) {
 7703   
                         case 1 :
 7704   
                             // com\\googlecode\\sparkleg\\Sparql.g:254:7: GRAPH
 7705   
                             {
 7706  0 
                             GRAPH169=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2033);
 7707  0 
                             GRAPH169_tree =
 7708   
                             (Object)adaptor.create(GRAPH169)
 7709   
                             ;
 7710  0 
                             adaptor.addChild(root_0, GRAPH169_tree);
 7711   
 
 7712   
 
 7713   
                             }
 7714   
                             break;
 7715   
 
 7716   
                     }
 7717   
 
 7718   
 
 7719  0 
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2036);
 7720  0 
                     iriRef170=iriRef();
 7721   
 
 7722  0 
                     state._fsp--;
 7723   
 
 7724  0 
                     adaptor.addChild(root_0, iriRef170.getTree());
 7725   
 
 7726   
                     }
 7727   
                     break;
 7728   
 
 7729   
             }
 7730  0 
             retval.stop = input.LT(-1);
 7731   
 
 7732   
 
 7733  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7734  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7735   
 
 7736   
         }
 7737  0 
         catch (RecognitionException re) {
 7738  0 
             reportError(re);
 7739  0 
             recover(input,re);
 7740  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7741   
 
 7742   
         }
 7743   
 
 7744  0 
         finally {
 7745   
                 // do for sure before leaving
 7746  0 
         }
 7747  0 
         return retval;
 7748   
     }
 7749   
     // $ANTLR end "graphOrDefault"
 7750   
 
 7751   
 
 7752  4 
     public static class graphRef_return extends ParserRuleReturnScope {
 7753   
         Object tree;
 7754  4 
         public Object getTree() { return tree; }
 7755   
     };
 7756   
 
 7757   
 
 7758   
     // $ANTLR start "graphRef"
 7759   
     // com\\googlecode\\sparkleg\\Sparql.g:257:1: graphRef : GRAPH iriRef ;
 7760   
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7761  4 
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7762  4 
         retval.start = input.LT(1);
 7763   
 
 7764   
 
 7765  4 
         Object root_0 = null;
 7766   
 
 7767  4 
         Token GRAPH171=null;
 7768  4 
         SparqlParser.iriRef_return iriRef172 =null;
 7769   
 
 7770   
 
 7771  4 
         Object GRAPH171_tree=null;
 7772   
 
 7773   
         try {
 7774   
             // com\\googlecode\\sparkleg\\Sparql.g:258:5: ( GRAPH iriRef )
 7775   
             // com\\googlecode\\sparkleg\\Sparql.g:258:7: GRAPH iriRef
 7776   
             {
 7777  4 
             root_0 = (Object)adaptor.nil();
 7778   
 
 7779   
 
 7780  4 
             GRAPH171=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2063);
 7781  4 
             GRAPH171_tree =
 7782   
             (Object)adaptor.create(GRAPH171)
 7783   
             ;
 7784  4 
             adaptor.addChild(root_0, GRAPH171_tree);
 7785   
 
 7786   
 
 7787  4 
             pushFollow(FOLLOW_iriRef_in_graphRef2065);
 7788  4 
             iriRef172=iriRef();
 7789   
 
 7790  4 
             state._fsp--;
 7791   
 
 7792  4 
             adaptor.addChild(root_0, iriRef172.getTree());
 7793   
 
 7794   
             }
 7795   
 
 7796  4 
             retval.stop = input.LT(-1);
 7797   
 
 7798   
 
 7799  4 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7800  4 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7801   
 
 7802   
         }
 7803  0 
         catch (RecognitionException re) {
 7804  0 
             reportError(re);
 7805  0 
             recover(input,re);
 7806  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7807   
 
 7808   
         }
 7809   
 
 7810  0 
         finally {
 7811   
                 // do for sure before leaving
 7812  4 
         }
 7813  4 
         return retval;
 7814   
     }
 7815   
     // $ANTLR end "graphRef"
 7816   
 
 7817   
 
 7818  16 
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7819   
         Object tree;
 7820  16 
         public Object getTree() { return tree; }
 7821   
     };
 7822   
 
 7823   
 
 7824   
     // $ANTLR start "graphRefAll"
 7825   
     // com\\googlecode\\sparkleg\\Sparql.g:261:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7826   
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7827  16 
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7828  16 
         retval.start = input.LT(1);
 7829   
 
 7830   
 
 7831  16 
         Object root_0 = null;
 7832   
 
 7833  16 
         Token DEFAULT174=null;
 7834  16 
         Token NAMED175=null;
 7835  16 
         Token ALL176=null;
 7836  16 
         SparqlParser.graphRef_return graphRef173 =null;
 7837   
 
 7838   
 
 7839  16 
         Object DEFAULT174_tree=null;
 7840  16 
         Object NAMED175_tree=null;
 7841  16 
         Object ALL176_tree=null;
 7842   
 
 7843   
         try {
 7844   
             // com\\googlecode\\sparkleg\\Sparql.g:262:5: ( graphRef | DEFAULT | NAMED | ALL )
 7845  16 
             int alt57=4;
 7846  16 
             switch ( input.LA(1) ) {
 7847   
             case GRAPH:
 7848   
                 {
 7849  4 
                 alt57=1;
 7850   
                 }
 7851  4 
                 break;
 7852   
             case DEFAULT:
 7853   
                 {
 7854  4 
                 alt57=2;
 7855   
                 }
 7856  4 
                 break;
 7857   
             case NAMED:
 7858   
                 {
 7859  4 
                 alt57=3;
 7860   
                 }
 7861  4 
                 break;
 7862   
             case ALL:
 7863   
                 {
 7864  4 
                 alt57=4;
 7865   
                 }
 7866  4 
                 break;
 7867   
             default:
 7868  0 
                 NoViableAltException nvae =
 7869   
                     new NoViableAltException("", 57, 0, input);
 7870   
 
 7871  0 
                 throw nvae;
 7872   
 
 7873   
             }
 7874   
 
 7875  16 
             switch (alt57) {
 7876   
                 case 1 :
 7877   
                     // com\\googlecode\\sparkleg\\Sparql.g:262:7: graphRef
 7878   
                     {
 7879  4 
                     root_0 = (Object)adaptor.nil();
 7880   
 
 7881   
 
 7882  4 
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2082);
 7883  4 
                     graphRef173=graphRef();
 7884   
 
 7885  4 
                     state._fsp--;
 7886   
 
 7887  4 
                     adaptor.addChild(root_0, graphRef173.getTree());
 7888   
 
 7889   
                     }
 7890  4 
                     break;
 7891   
                 case 2 :
 7892   
                     // com\\googlecode\\sparkleg\\Sparql.g:262:18: DEFAULT
 7893   
                     {
 7894  4 
                     root_0 = (Object)adaptor.nil();
 7895   
 
 7896   
 
 7897  4 
                     DEFAULT174=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2086);
 7898  4 
                     DEFAULT174_tree =
 7899   
                     (Object)adaptor.create(DEFAULT174)
 7900   
                     ;
 7901  4 
                     adaptor.addChild(root_0, DEFAULT174_tree);
 7902   
 
 7903   
 
 7904   
                     }
 7905  4 
                     break;
 7906   
                 case 3 :
 7907   
                     // com\\googlecode\\sparkleg\\Sparql.g:262:28: NAMED
 7908   
                     {
 7909  4 
                     root_0 = (Object)adaptor.nil();
 7910   
 
 7911   
 
 7912  4 
                     NAMED175=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2090);
 7913  4 
                     NAMED175_tree =
 7914   
                     (Object)adaptor.create(NAMED175)
 7915   
                     ;
 7916  4 
                     adaptor.addChild(root_0, NAMED175_tree);
 7917   
 
 7918   
 
 7919   
                     }
 7920  4 
                     break;
 7921   
                 case 4 :
 7922   
                     // com\\googlecode\\sparkleg\\Sparql.g:262:36: ALL
 7923   
                     {
 7924  4 
                     root_0 = (Object)adaptor.nil();
 7925   
 
 7926   
 
 7927  4 
                     ALL176=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2094);
 7928  4 
                     ALL176_tree =
 7929   
                     (Object)adaptor.create(ALL176)
 7930   
                     ;
 7931  4 
                     adaptor.addChild(root_0, ALL176_tree);
 7932   
 
 7933   
 
 7934   
                     }
 7935   
                     break;
 7936   
 
 7937   
             }
 7938  16 
             retval.stop = input.LT(-1);
 7939   
 
 7940   
 
 7941  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7942  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7943   
 
 7944   
         }
 7945  0 
         catch (RecognitionException re) {
 7946  0 
             reportError(re);
 7947  0 
             recover(input,re);
 7948  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7949   
 
 7950   
         }
 7951   
 
 7952  0 
         finally {
 7953   
                 // do for sure before leaving
 7954  16 
         }
 7955  16 
         return retval;
 7956   
     }
 7957   
     // $ANTLR end "graphRefAll"
 7958   
 
 7959   
 
 7960  122 
     public static class quadPattern_return extends ParserRuleReturnScope {
 7961   
         Object tree;
 7962  122 
         public Object getTree() { return tree; }
 7963   
     };
 7964   
 
 7965   
 
 7966   
     // $ANTLR start "quadPattern"
 7967   
     // com\\googlecode\\sparkleg\\Sparql.g:265:1: quadPattern : OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads ;
 7968   
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 7969  122 
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 7970  122 
         retval.start = input.LT(1);
 7971   
 
 7972   
 
 7973  122 
         Object root_0 = null;
 7974   
 
 7975  122 
         Token OPEN_CURLY_BRACE177=null;
 7976  122 
         Token CLOSE_CURLY_BRACE179=null;
 7977  122 
         SparqlParser.quads_return quads178 =null;
 7978   
 
 7979   
 
 7980  122 
         Object OPEN_CURLY_BRACE177_tree=null;
 7981  122 
         Object CLOSE_CURLY_BRACE179_tree=null;
 7982  122 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 7983  122 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 7984  122 
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 7985   
         try {
 7986   
             // com\\googlecode\\sparkleg\\Sparql.g:266:5: ( OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads )
 7987   
             // com\\googlecode\\sparkleg\\Sparql.g:266:7: OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE
 7988   
             {
 7989  122 
             OPEN_CURLY_BRACE177=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2111);
 7990  122 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE177);
 7991   
 
 7992   
 
 7993  122 
             pushFollow(FOLLOW_quads_in_quadPattern2113);
 7994  122 
             quads178=quads();
 7995   
 
 7996  122 
             state._fsp--;
 7997   
 
 7998  122 
             stream_quads.add(quads178.getTree());
 7999   
 
 8000  122 
             CLOSE_CURLY_BRACE179=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2115);
 8001  122 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE179);
 8002   
 
 8003   
 
 8004   
             // AST REWRITE
 8005   
             // elements: quads
 8006   
             // token labels:
 8007   
             // rule labels: retval
 8008   
             // token list labels:
 8009   
             // rule list labels:
 8010   
             // wildcard labels:
 8011  122 
             retval.tree = root_0;
 8012  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8013   
 
 8014  122 
             root_0 = (Object)adaptor.nil();
 8015   
             // 266:48: -> quads
 8016   
             {
 8017  122 
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8018   
 
 8019   
             }
 8020   
 
 8021   
 
 8022  122 
             retval.tree = root_0;
 8023   
 
 8024   
             }
 8025   
 
 8026  122 
             retval.stop = input.LT(-1);
 8027   
 
 8028   
 
 8029  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8030  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8031   
 
 8032   
         }
 8033  0 
         catch (RecognitionException re) {
 8034  0 
             reportError(re);
 8035  0 
             recover(input,re);
 8036  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8037   
 
 8038   
         }
 8039   
 
 8040  0 
         finally {
 8041   
                 // do for sure before leaving
 8042  122 
         }
 8043  122 
         return retval;
 8044   
     }
 8045   
     // $ANTLR end "quadPattern"
 8046   
 
 8047   
 
 8048  122 
     public static class quads_return extends ParserRuleReturnScope {
 8049   
         Object tree;
 8050  122 
         public Object getTree() { return tree; }
 8051   
     };
 8052   
 
 8053   
 
 8054   
     // $ANTLR start "quads"
 8055   
     // com\\googlecode\\sparkleg\\Sparql.g:269:1: quads : ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )* -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* ;
 8056   
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8057  122 
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8058  122 
         retval.start = input.LT(1);
 8059   
 
 8060   
 
 8061  122 
         Object root_0 = null;
 8062   
 
 8063  122 
         Token DOT182=null;
 8064  122 
         SparqlParser.triplesTemplate_return triplesTemplate180 =null;
 8065   
 
 8066  122 
         SparqlParser.quadsNotTriples_return quadsNotTriples181 =null;
 8067   
 
 8068  122 
         SparqlParser.triplesTemplate_return triplesTemplate183 =null;
 8069   
 
 8070   
 
 8071  122 
         Object DOT182_tree=null;
 8072  122 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8073  122 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8074  122 
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8075   
         try {
 8076   
             // com\\googlecode\\sparkleg\\Sparql.g:270:5: ( ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )* -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* )
 8077   
             // com\\googlecode\\sparkleg\\Sparql.g:270:7: ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )*
 8078   
             {
 8079   
             // com\\googlecode\\sparkleg\\Sparql.g:270:7: ( triplesTemplate )?
 8080  122 
             int alt58=2;
 8081  122 
             switch ( input.LA(1) ) {
 8082   
                 case BLANK_NODE_LABEL:
 8083   
                 case DECIMAL:
 8084   
                 case DECIMAL_NEGATIVE:
 8085   
                 case DECIMAL_POSITIVE:
 8086   
                 case DOUBLE:
 8087   
                 case DOUBLE_NEGATIVE:
 8088   
                 case DOUBLE_POSITIVE:
 8089   
                 case FALSE:
 8090   
                 case INTEGER:
 8091   
                 case INTEGER_NEGATIVE:
 8092   
                 case INTEGER_POSITIVE:
 8093   
                 case IRI_REF:
 8094   
                 case OPEN_BRACE:
 8095   
                 case OPEN_SQUARE_BRACKET:
 8096   
                 case PNAME_LN:
 8097   
                 case PNAME_NS:
 8098   
                 case STRING_LITERAL1:
 8099   
                 case STRING_LITERAL2:
 8100   
                 case STRING_LITERAL_LONG1:
 8101   
                 case STRING_LITERAL_LONG2:
 8102   
                 case TRUE:
 8103   
                 case VAR1:
 8104   
                 case VAR2:
 8105   
                     {
 8106  88 
                     alt58=1;
 8107   
                     }
 8108   
                     break;
 8109   
             }
 8110   
 
 8111  122 
             switch (alt58) {
 8112   
                 case 1 :
 8113   
                     // com\\googlecode\\sparkleg\\Sparql.g:270:7: triplesTemplate
 8114   
                     {
 8115  88 
                     pushFollow(FOLLOW_triplesTemplate_in_quads2140);
 8116  88 
                     triplesTemplate180=triplesTemplate();
 8117   
 
 8118  88 
                     state._fsp--;
 8119   
 
 8120  88 
                     stream_triplesTemplate.add(triplesTemplate180.getTree());
 8121   
 
 8122   
                     }
 8123   
                     break;
 8124   
 
 8125   
             }
 8126   
 
 8127   
 
 8128   
             // com\\googlecode\\sparkleg\\Sparql.g:270:24: ( quadsNotTriples ( DOT )? ( triplesTemplate )? )*
 8129   
             loop61:
 8130   
             do {
 8131  156 
                 int alt61=2;
 8132  156 
                 switch ( input.LA(1) ) {
 8133   
                 case GRAPH:
 8134   
                     {
 8135  34 
                     alt61=1;
 8136   
                     }
 8137   
                     break;
 8138   
 
 8139   
                 }
 8140   
 
 8141  156 
                 switch (alt61) {
 8142   
                     case 1 :
 8143   
                         // com\\googlecode\\sparkleg\\Sparql.g:270:25: quadsNotTriples ( DOT )? ( triplesTemplate )?
 8144   
                         {
 8145  34 
                         pushFollow(FOLLOW_quadsNotTriples_in_quads2144);
 8146  34 
                         quadsNotTriples181=quadsNotTriples();
 8147   
 
 8148  34 
                         state._fsp--;
 8149   
 
 8150  34 
                         stream_quadsNotTriples.add(quadsNotTriples181.getTree());
 8151   
 
 8152   
                         // com\\googlecode\\sparkleg\\Sparql.g:270:41: ( DOT )?
 8153  34 
                         int alt59=2;
 8154  34 
                         switch ( input.LA(1) ) {
 8155   
                             case DOT:
 8156   
                                 {
 8157  0 
                                 alt59=1;
 8158   
                                 }
 8159   
                                 break;
 8160   
                         }
 8161   
 
 8162  34 
                         switch (alt59) {
 8163   
                             case 1 :
 8164   
                                 // com\\googlecode\\sparkleg\\Sparql.g:270:41: DOT
 8165   
                                 {
 8166  0 
                                 DOT182=(Token)match(input,DOT,FOLLOW_DOT_in_quads2146);
 8167  0 
                                 stream_DOT.add(DOT182);
 8168   
 
 8169   
 
 8170   
                                 }
 8171   
                                 break;
 8172   
 
 8173   
                         }
 8174   
 
 8175   
 
 8176   
                         // com\\googlecode\\sparkleg\\Sparql.g:270:46: ( triplesTemplate )?
 8177  34 
                         int alt60=2;
 8178  34 
                         switch ( input.LA(1) ) {
 8179   
                             case BLANK_NODE_LABEL:
 8180   
                             case DECIMAL:
 8181   
                             case DECIMAL_NEGATIVE:
 8182   
                             case DECIMAL_POSITIVE:
 8183   
                             case DOUBLE:
 8184   
                             case DOUBLE_NEGATIVE:
 8185   
                             case DOUBLE_POSITIVE:
 8186   
                             case FALSE:
 8187   
                             case INTEGER:
 8188   
                             case INTEGER_NEGATIVE:
 8189   
                             case INTEGER_POSITIVE:
 8190   
                             case IRI_REF:
 8191   
                             case OPEN_BRACE:
 8192   
                             case OPEN_SQUARE_BRACKET:
 8193   
                             case PNAME_LN:
 8194   
                             case PNAME_NS:
 8195   
                             case STRING_LITERAL1:
 8196   
                             case STRING_LITERAL2:
 8197   
                             case STRING_LITERAL_LONG1:
 8198   
                             case STRING_LITERAL_LONG2:
 8199   
                             case TRUE:
 8200   
                             case VAR1:
 8201   
                             case VAR2:
 8202   
                                 {
 8203  0 
                                 alt60=1;
 8204   
                                 }
 8205   
                                 break;
 8206   
                         }
 8207   
 
 8208  34 
                         switch (alt60) {
 8209   
                             case 1 :
 8210   
                                 // com\\googlecode\\sparkleg\\Sparql.g:270:46: triplesTemplate
 8211   
                                 {
 8212  0 
                                 pushFollow(FOLLOW_triplesTemplate_in_quads2149);
 8213  0 
                                 triplesTemplate183=triplesTemplate();
 8214   
 
 8215  0 
                                 state._fsp--;
 8216   
 
 8217  0 
                                 stream_triplesTemplate.add(triplesTemplate183.getTree());
 8218   
 
 8219   
                                 }
 8220   
                                 break;
 8221   
 
 8222   
                         }
 8223   
 
 8224   
 
 8225   
                         }
 8226  34 
                         break;
 8227   
 
 8228   
                     default :
 8229  122 
                         break loop61;
 8230   
                 }
 8231  34 
             } while (true);
 8232   
 
 8233   
 
 8234   
             // AST REWRITE
 8235   
             // elements: triplesTemplate, triplesTemplate, quadsNotTriples
 8236   
             // token labels:
 8237   
             // rule labels: retval
 8238   
             // token list labels:
 8239   
             // rule list labels:
 8240   
             // wildcard labels:
 8241  122 
             retval.tree = root_0;
 8242  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8243   
 
 8244  122 
             root_0 = (Object)adaptor.nil();
 8245   
             // 270:65: -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )*
 8246   
             {
 8247   
                 // com\\googlecode\\sparkleg\\Sparql.g:270:69: ( triplesTemplate )?
 8248  122 
                 if ( stream_triplesTemplate.hasNext() ) {
 8249  88 
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8250   
 
 8251   
                 }
 8252  122 
                 stream_triplesTemplate.reset();
 8253   
 
 8254   
                 // com\\googlecode\\sparkleg\\Sparql.g:270:86: ( quadsNotTriples ( triplesTemplate )? )*
 8255  156 
                 while ( stream_quadsNotTriples.hasNext() ) {
 8256  34 
                     adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8257   
 
 8258   
                     // com\\googlecode\\sparkleg\\Sparql.g:270:103: ( triplesTemplate )?
 8259  34 
                     if ( stream_triplesTemplate.hasNext() ) {
 8260  0 
                         adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8261   
 
 8262   
                     }
 8263  34 
                     stream_triplesTemplate.reset();
 8264   
 
 8265   
                 }
 8266  122 
                 stream_quadsNotTriples.reset();
 8267   
 
 8268   
             }
 8269   
 
 8270   
 
 8271  122 
             retval.tree = root_0;
 8272   
 
 8273   
             }
 8274   
 
 8275  122 
             retval.stop = input.LT(-1);
 8276   
 
 8277   
 
 8278  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8279  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8280   
 
 8281   
         }
 8282  0 
         catch (RecognitionException re) {
 8283  0 
             reportError(re);
 8284  0 
             recover(input,re);
 8285  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8286   
 
 8287   
         }
 8288   
 
 8289  0 
         finally {
 8290   
                 // do for sure before leaving
 8291  122 
         }
 8292  122 
         return retval;
 8293   
     }
 8294   
     // $ANTLR end "quads"
 8295   
 
 8296   
 
 8297  34 
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8298   
         Object tree;
 8299  34 
         public Object getTree() { return tree; }
 8300   
     };
 8301   
 
 8302   
 
 8303   
     // $ANTLR start "quadsNotTriples"
 8304   
     // com\\googlecode\\sparkleg\\Sparql.g:273:1: quadsNotTriples : GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8305   
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8306  34 
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8307  34 
         retval.start = input.LT(1);
 8308   
 
 8309   
 
 8310  34 
         Object root_0 = null;
 8311   
 
 8312  34 
         Token GRAPH184=null;
 8313  34 
         Token OPEN_CURLY_BRACE186=null;
 8314  34 
         Token CLOSE_CURLY_BRACE188=null;
 8315  34 
         SparqlParser.varOrIRIref_return varOrIRIref185 =null;
 8316   
 
 8317  34 
         SparqlParser.triplesTemplate_return triplesTemplate187 =null;
 8318   
 
 8319   
 
 8320  34 
         Object GRAPH184_tree=null;
 8321  34 
         Object OPEN_CURLY_BRACE186_tree=null;
 8322  34 
         Object CLOSE_CURLY_BRACE188_tree=null;
 8323  34 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8324  34 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8325  34 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8326  34 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8327  34 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8328   
         try {
 8329   
             // com\\googlecode\\sparkleg\\Sparql.g:274:5: ( GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8330   
             // com\\googlecode\\sparkleg\\Sparql.g:274:7: GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE
 8331   
             {
 8332  34 
             GRAPH184=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2188);
 8333  34 
             stream_GRAPH.add(GRAPH184);
 8334   
 
 8335   
 
 8336  34 
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2190);
 8337  34 
             varOrIRIref185=varOrIRIref();
 8338   
 
 8339  34 
             state._fsp--;
 8340   
 
 8341  34 
             stream_varOrIRIref.add(varOrIRIref185.getTree());
 8342   
 
 8343  34 
             OPEN_CURLY_BRACE186=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2192);
 8344  34 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE186);
 8345   
 
 8346   
 
 8347   
             // com\\googlecode\\sparkleg\\Sparql.g:274:42: ( triplesTemplate )?
 8348  34 
             int alt62=2;
 8349  34 
             switch ( input.LA(1) ) {
 8350   
                 case BLANK_NODE_LABEL:
 8351   
                 case DECIMAL:
 8352   
                 case DECIMAL_NEGATIVE:
 8353   
                 case DECIMAL_POSITIVE:
 8354   
                 case DOUBLE:
 8355   
                 case DOUBLE_NEGATIVE:
 8356   
                 case DOUBLE_POSITIVE:
 8357   
                 case FALSE:
 8358   
                 case INTEGER:
 8359   
                 case INTEGER_NEGATIVE:
 8360   
                 case INTEGER_POSITIVE:
 8361   
                 case IRI_REF:
 8362   
                 case OPEN_BRACE:
 8363   
                 case OPEN_SQUARE_BRACKET:
 8364   
                 case PNAME_LN:
 8365   
                 case PNAME_NS:
 8366   
                 case STRING_LITERAL1:
 8367   
                 case STRING_LITERAL2:
 8368   
                 case STRING_LITERAL_LONG1:
 8369   
                 case STRING_LITERAL_LONG2:
 8370   
                 case TRUE:
 8371   
                 case VAR1:
 8372   
                 case VAR2:
 8373   
                     {
 8374  34 
                     alt62=1;
 8375   
                     }
 8376   
                     break;
 8377   
             }
 8378   
 
 8379  34 
             switch (alt62) {
 8380   
                 case 1 :
 8381   
                     // com\\googlecode\\sparkleg\\Sparql.g:274:42: triplesTemplate
 8382   
                     {
 8383  34 
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2194);
 8384  34 
                     triplesTemplate187=triplesTemplate();
 8385   
 
 8386  34 
                     state._fsp--;
 8387   
 
 8388  34 
                     stream_triplesTemplate.add(triplesTemplate187.getTree());
 8389   
 
 8390   
                     }
 8391   
                     break;
 8392   
 
 8393   
             }
 8394   
 
 8395   
 
 8396  34 
             CLOSE_CURLY_BRACE188=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2197);
 8397  34 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE188);
 8398   
 
 8399   
 
 8400   
             // AST REWRITE
 8401   
             // elements: varOrIRIref, GRAPH, triplesTemplate
 8402   
             // token labels:
 8403   
             // rule labels: retval
 8404   
             // token list labels:
 8405   
             // rule list labels:
 8406   
             // wildcard labels:
 8407  34 
             retval.tree = root_0;
 8408  34 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8409   
 
 8410  34 
             root_0 = (Object)adaptor.nil();
 8411   
             // 274:77: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8412   
             {
 8413   
                 // com\\googlecode\\sparkleg\\Sparql.g:274:80: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8414   
                 {
 8415  34 
                 Object root_1 = (Object)adaptor.nil();
 8416  34 
                 root_1 = (Object)adaptor.becomeRoot(
 8417   
                 stream_GRAPH.nextNode()
 8418   
                 , root_1);
 8419   
 
 8420  34 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8421   
 
 8422   
                 // com\\googlecode\\sparkleg\\Sparql.g:274:100: ( triplesTemplate )?
 8423  34 
                 if ( stream_triplesTemplate.hasNext() ) {
 8424  34 
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8425   
 
 8426   
                 }
 8427  34 
                 stream_triplesTemplate.reset();
 8428   
 
 8429  34 
                 adaptor.addChild(root_0, root_1);
 8430   
                 }
 8431   
 
 8432   
             }
 8433   
 
 8434   
 
 8435  34 
             retval.tree = root_0;
 8436   
 
 8437   
             }
 8438   
 
 8439  34 
             retval.stop = input.LT(-1);
 8440   
 
 8441   
 
 8442  34 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8443  34 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8444   
 
 8445   
         }
 8446  0 
         catch (RecognitionException re) {
 8447  0 
             reportError(re);
 8448  0 
             recover(input,re);
 8449  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8450   
 
 8451   
         }
 8452   
 
 8453  0 
         finally {
 8454   
                 // do for sure before leaving
 8455  34 
         }
 8456  34 
         return retval;
 8457   
     }
 8458   
     // $ANTLR end "quadsNotTriples"
 8459   
 
 8460   
 
 8461  122 
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8462   
         Object tree;
 8463  122 
         public Object getTree() { return tree; }
 8464   
     };
 8465   
 
 8466   
 
 8467   
     // $ANTLR start "triplesTemplate"
 8468   
     // com\\googlecode\\sparkleg\\Sparql.g:277:1: triplesTemplate : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8469   
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8470  122 
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8471  122 
         retval.start = input.LT(1);
 8472   
 
 8473   
 
 8474  122 
         Object root_0 = null;
 8475   
 
 8476  122 
         Token DOT190=null;
 8477  122 
         Token DOT192=null;
 8478  122 
         SparqlParser.triplesSameSubject_return triplesSameSubject189 =null;
 8479   
 
 8480  122 
         SparqlParser.triplesSameSubject_return triplesSameSubject191 =null;
 8481   
 
 8482   
 
 8483  122 
         Object DOT190_tree=null;
 8484  122 
         Object DOT192_tree=null;
 8485  122 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8486  122 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8487   
         try {
 8488   
             // com\\googlecode\\sparkleg\\Sparql.g:278:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8489   
             // com\\googlecode\\sparkleg\\Sparql.g:278:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 8490   
             {
 8491  122 
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2229);
 8492  122 
             triplesSameSubject189=triplesSameSubject();
 8493   
 
 8494  122 
             state._fsp--;
 8495   
 
 8496  122 
             stream_triplesSameSubject.add(triplesSameSubject189.getTree());
 8497   
 
 8498   
             // com\\googlecode\\sparkleg\\Sparql.g:278:26: ( DOT triplesSameSubject )*
 8499   
             loop63:
 8500   
             do {
 8501  126 
                 int alt63=2;
 8502  126 
                 switch ( input.LA(1) ) {
 8503   
                 case DOT:
 8504   
                     {
 8505  82 
                     switch ( input.LA(2) ) {
 8506   
                     case BLANK_NODE_LABEL:
 8507   
                     case DECIMAL:
 8508   
                     case DECIMAL_NEGATIVE:
 8509   
                     case DECIMAL_POSITIVE:
 8510   
                     case DOUBLE:
 8511   
                     case DOUBLE_NEGATIVE:
 8512   
                     case DOUBLE_POSITIVE:
 8513   
                     case FALSE:
 8514   
                     case INTEGER:
 8515   
                     case INTEGER_NEGATIVE:
 8516   
                     case INTEGER_POSITIVE:
 8517   
                     case IRI_REF:
 8518   
                     case OPEN_BRACE:
 8519   
                     case OPEN_SQUARE_BRACKET:
 8520   
                     case PNAME_LN:
 8521   
                     case PNAME_NS:
 8522   
                     case STRING_LITERAL1:
 8523   
                     case STRING_LITERAL2:
 8524   
                     case STRING_LITERAL_LONG1:
 8525   
                     case STRING_LITERAL_LONG2:
 8526   
                     case TRUE:
 8527   
                     case VAR1:
 8528   
                     case VAR2:
 8529   
                         {
 8530  4 
                         alt63=1;
 8531   
                         }
 8532   
                         break;
 8533   
 
 8534   
                     }
 8535   
 
 8536   
                     }
 8537   
                     break;
 8538   
 
 8539   
                 }
 8540   
 
 8541  126 
                 switch (alt63) {
 8542   
                     case 1 :
 8543   
                         // com\\googlecode\\sparkleg\\Sparql.g:278:27: DOT triplesSameSubject
 8544   
                         {
 8545  4 
                         DOT190=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2232);
 8546  4 
                         stream_DOT.add(DOT190);
 8547   
 
 8548   
 
 8549  4 
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2234);
 8550  4 
                         triplesSameSubject191=triplesSameSubject();
 8551   
 
 8552  4 
                         state._fsp--;
 8553   
 
 8554  4 
                         stream_triplesSameSubject.add(triplesSameSubject191.getTree());
 8555   
 
 8556   
                         }
 8557  4 
                         break;
 8558   
 
 8559   
                     default :
 8560  122 
                         break loop63;
 8561   
                 }
 8562  4 
             } while (true);
 8563   
 
 8564   
 
 8565   
             // com\\googlecode\\sparkleg\\Sparql.g:278:52: ( DOT )?
 8566  122 
             int alt64=2;
 8567  122 
             switch ( input.LA(1) ) {
 8568   
                 case DOT:
 8569   
                     {
 8570  78 
                     alt64=1;
 8571   
                     }
 8572   
                     break;
 8573   
             }
 8574   
 
 8575  122 
             switch (alt64) {
 8576   
                 case 1 :
 8577   
                     // com\\googlecode\\sparkleg\\Sparql.g:278:52: DOT
 8578   
                     {
 8579  78 
                     DOT192=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2238);
 8580  78 
                     stream_DOT.add(DOT192);
 8581   
 
 8582   
 
 8583   
                     }
 8584   
                     break;
 8585   
 
 8586   
             }
 8587   
 
 8588   
 
 8589   
             // AST REWRITE
 8590   
             // elements: triplesSameSubject
 8591   
             // token labels:
 8592   
             // rule labels: retval
 8593   
             // token list labels:
 8594   
             // rule list labels:
 8595   
             // wildcard labels:
 8596  122 
             retval.tree = root_0;
 8597  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8598   
 
 8599  122 
             root_0 = (Object)adaptor.nil();
 8600   
             // 278:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8601   
             {
 8602   
                 // com\\googlecode\\sparkleg\\Sparql.g:278:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8603   
                 {
 8604  122 
                 Object root_1 = (Object)adaptor.nil();
 8605  122 
                 root_1 = (Object)adaptor.becomeRoot(
 8606   
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8607   
                 , root_1);
 8608   
 
 8609   
                 // com\\googlecode\\sparkleg\\Sparql.g:278:79: ( triplesSameSubject )*
 8610  248 
                 while ( stream_triplesSameSubject.hasNext() ) {
 8611  126 
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8612   
 
 8613   
                 }
 8614  122 
                 stream_triplesSameSubject.reset();
 8615   
 
 8616  122 
                 adaptor.addChild(root_0, root_1);
 8617   
                 }
 8618   
 
 8619   
             }
 8620   
 
 8621   
 
 8622  122 
             retval.tree = root_0;
 8623   
 
 8624   
             }
 8625   
 
 8626  122 
             retval.stop = input.LT(-1);
 8627   
 
 8628   
 
 8629  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8630  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8631   
 
 8632   
         }
 8633  0 
         catch (RecognitionException re) {
 8634  0 
             reportError(re);
 8635  0 
             recover(input,re);
 8636  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8637   
 
 8638   
         }
 8639   
 
 8640  0 
         finally {
 8641   
                 // do for sure before leaving
 8642  122 
         }
 8643  122 
         return retval;
 8644   
     }
 8645   
     // $ANTLR end "triplesTemplate"
 8646   
 
 8647   
 
 8648  2710 
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8649   
         Object tree;
 8650  2710 
         public Object getTree() { return tree; }
 8651   
     };
 8652   
 
 8653   
 
 8654   
     // $ANTLR start "groupGraphPattern"
 8655   
     // com\\googlecode\\sparkleg\\Sparql.g:281:1: groupGraphPattern : ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8656   
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8657  2710 
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8658  2710 
         retval.start = input.LT(1);
 8659   
 
 8660   
 
 8661  2710 
         Object root_0 = null;
 8662   
 
 8663  2710 
         Token OPEN_CURLY_BRACE193=null;
 8664  2710 
         Token CLOSE_CURLY_BRACE195=null;
 8665  2710 
         Token OPEN_CURLY_BRACE196=null;
 8666  2710 
         Token CLOSE_CURLY_BRACE198=null;
 8667  2710 
         Token OPEN_CURLY_BRACE199=null;
 8668  2710 
         Token CLOSE_CURLY_BRACE200=null;
 8669  2710 
         SparqlParser.subSelect_return subSelect194 =null;
 8670   
 
 8671  2710 
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub197 =null;
 8672   
 
 8673   
 
 8674  2710 
         Object OPEN_CURLY_BRACE193_tree=null;
 8675  2710 
         Object CLOSE_CURLY_BRACE195_tree=null;
 8676  2710 
         Object OPEN_CURLY_BRACE196_tree=null;
 8677  2710 
         Object CLOSE_CURLY_BRACE198_tree=null;
 8678  2710 
         Object OPEN_CURLY_BRACE199_tree=null;
 8679  2710 
         Object CLOSE_CURLY_BRACE200_tree=null;
 8680  2710 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8681  2710 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8682  2710 
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8683  2710 
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8684   
         try {
 8685   
             // com\\googlecode\\sparkleg\\Sparql.g:282:5: ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8686  2710 
             int alt65=3;
 8687  2710 
             switch ( input.LA(1) ) {
 8688   
             case OPEN_CURLY_BRACE:
 8689   
                 {
 8690  2698 
                 switch ( input.LA(2) ) {
 8691   
                 case CLOSE_CURLY_BRACE:
 8692   
                     {
 8693  44 
                     alt65=3;
 8694   
                     }
 8695  44 
                     break;
 8696   
                 case SELECT:
 8697   
                     {
 8698  46 
                     alt65=1;
 8699   
                     }
 8700  46 
                     break;
 8701   
                 case BIND:
 8702   
                 case BLANK_NODE_LABEL:
 8703   
                 case DECIMAL:
 8704   
                 case DECIMAL_NEGATIVE:
 8705   
                 case DECIMAL_POSITIVE:
 8706   
                 case DOUBLE:
 8707   
                 case DOUBLE_NEGATIVE:
 8708   
                 case DOUBLE_POSITIVE:
 8709   
                 case FALSE:
 8710   
                 case FILTER:
 8711   
                 case GRAPH:
 8712   
                 case INTEGER:
 8713   
                 case INTEGER_NEGATIVE:
 8714   
                 case INTEGER_POSITIVE:
 8715   
                 case IRI_REF:
 8716   
                 case MINUS_KEYWORD:
 8717   
                 case OPEN_BRACE:
 8718   
                 case OPEN_CURLY_BRACE:
 8719   
                 case OPEN_SQUARE_BRACKET:
 8720   
                 case OPTIONAL:
 8721   
                 case PNAME_LN:
 8722   
                 case PNAME_NS:
 8723   
                 case SERVICE:
 8724   
                 case STRING_LITERAL1:
 8725   
                 case STRING_LITERAL2:
 8726   
                 case STRING_LITERAL_LONG1:
 8727   
                 case STRING_LITERAL_LONG2:
 8728   
                 case TRUE:
 8729   
                 case VAR1:
 8730   
                 case VAR2:
 8731   
                     {
 8732  2598 
                     alt65=2;
 8733   
                     }
 8734  2598 
                     break;
 8735   
                 default:
 8736  10 
                     NoViableAltException nvae =
 8737   
                         new NoViableAltException("", 65, 1, input);
 8738   
 
 8739  10 
                     throw nvae;
 8740   
 
 8741   
                 }
 8742   
 
 8743   
                 }
 8744  2688 
                 break;
 8745   
             default:
 8746  12 
                 NoViableAltException nvae =
 8747   
                     new NoViableAltException("", 65, 0, input);
 8748   
 
 8749  12 
                 throw nvae;
 8750   
 
 8751   
             }
 8752   
 
 8753  2688 
             switch (alt65) {
 8754   
                 case 1 :
 8755   
                     // com\\googlecode\\sparkleg\\Sparql.g:282:7: OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE
 8756   
                     {
 8757  46 
                     OPEN_CURLY_BRACE193=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2270);
 8758  46 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE193);
 8759   
 
 8760   
 
 8761  46 
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2272);
 8762  46 
                     subSelect194=subSelect();
 8763   
 
 8764  46 
                     state._fsp--;
 8765   
 
 8766  46 
                     stream_subSelect.add(subSelect194.getTree());
 8767   
 
 8768  46 
                     CLOSE_CURLY_BRACE195=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2274);
 8769  46 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE195);
 8770   
 
 8771   
 
 8772   
                     // AST REWRITE
 8773   
                     // elements: subSelect
 8774   
                     // token labels:
 8775   
                     // rule labels: retval
 8776   
                     // token list labels:
 8777   
                     // rule list labels:
 8778   
                     // wildcard labels:
 8779  46 
                     retval.tree = root_0;
 8780  46 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8781   
 
 8782  46 
                     root_0 = (Object)adaptor.nil();
 8783   
                     // 282:52: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8784   
                     {
 8785   
                         // com\\googlecode\\sparkleg\\Sparql.g:282:55: ^( GROUP_GRAPH_PATTERN subSelect )
 8786   
                         {
 8787  46 
                         Object root_1 = (Object)adaptor.nil();
 8788  46 
                         root_1 = (Object)adaptor.becomeRoot(
 8789   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8790   
                         , root_1);
 8791   
 
 8792  46 
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 8793   
 
 8794  46 
                         adaptor.addChild(root_0, root_1);
 8795   
                         }
 8796   
 
 8797   
                     }
 8798   
 
 8799   
 
 8800  46 
                     retval.tree = root_0;
 8801   
 
 8802   
                     }
 8803  46 
                     break;
 8804   
                 case 2 :
 8805   
                     // com\\googlecode\\sparkleg\\Sparql.g:283:7: OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE
 8806   
                     {
 8807  2598 
                     OPEN_CURLY_BRACE196=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2290);
 8808  2598 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE196);
 8809   
 
 8810   
 
 8811  2598 
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2292);
 8812  2598 
                     groupGraphPatternSub197=groupGraphPatternSub();
 8813   
 
 8814  2598 
                     state._fsp--;
 8815   
 
 8816  2598 
                     stream_groupGraphPatternSub.add(groupGraphPatternSub197.getTree());
 8817   
 
 8818  2598 
                     CLOSE_CURLY_BRACE198=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2294);
 8819  2580 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE198);
 8820   
 
 8821   
 
 8822   
                     // AST REWRITE
 8823   
                     // elements: groupGraphPatternSub
 8824   
                     // token labels:
 8825   
                     // rule labels: retval
 8826   
                     // token list labels:
 8827   
                     // rule list labels:
 8828   
                     // wildcard labels:
 8829  2580 
                     retval.tree = root_0;
 8830  2580 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8831   
 
 8832  2580 
                     root_0 = (Object)adaptor.nil();
 8833   
                     // 283:63: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8834   
                     {
 8835   
                         // com\\googlecode\\sparkleg\\Sparql.g:283:66: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8836   
                         {
 8837  2580 
                         Object root_1 = (Object)adaptor.nil();
 8838  2580 
                         root_1 = (Object)adaptor.becomeRoot(
 8839   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8840   
                         , root_1);
 8841   
 
 8842  2580 
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 8843   
 
 8844  2580 
                         adaptor.addChild(root_0, root_1);
 8845   
                         }
 8846   
 
 8847   
                     }
 8848   
 
 8849   
 
 8850  2580 
                     retval.tree = root_0;
 8851   
 
 8852   
                     }
 8853  2580 
                     break;
 8854   
                 case 3 :
 8855   
                     // com\\googlecode\\sparkleg\\Sparql.g:284:7: OPEN_CURLY_BRACE CLOSE_CURLY_BRACE
 8856   
                     {
 8857  44 
                     OPEN_CURLY_BRACE199=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2310);
 8858  44 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE199);
 8859   
 
 8860   
 
 8861  44 
                     CLOSE_CURLY_BRACE200=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2312);
 8862  44 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE200);
 8863   
 
 8864   
 
 8865   
                     // AST REWRITE
 8866   
                     // elements:
 8867   
                     // token labels:
 8868   
                     // rule labels: retval
 8869   
                     // token list labels:
 8870   
                     // rule list labels:
 8871   
                     // wildcard labels:
 8872  44 
                     retval.tree = root_0;
 8873  44 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8874   
 
 8875  44 
                     root_0 = (Object)adaptor.nil();
 8876   
                     // 284:42: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 8877   
                     {
 8878   
                         // com\\googlecode\\sparkleg\\Sparql.g:284:45: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 8879   
                         {
 8880  44 
                         Object root_1 = (Object)adaptor.nil();
 8881  44 
                         root_1 = (Object)adaptor.becomeRoot(
 8882   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8883   
                         , root_1);
 8884   
 
 8885  44 
                         adaptor.addChild(root_1,
 8886   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8887   
                         );
 8888   
 
 8889  44 
                         adaptor.addChild(root_0, root_1);
 8890   
                         }
 8891   
 
 8892   
                     }
 8893   
 
 8894   
 
 8895  44 
                     retval.tree = root_0;
 8896   
 
 8897   
                     }
 8898   
                     break;
 8899   
 
 8900   
             }
 8901  2670 
             retval.stop = input.LT(-1);
 8902   
 
 8903   
 
 8904  2670 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8905  2670 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8906   
 
 8907   
         }
 8908  40 
         catch (RecognitionException re) {
 8909  40 
             reportError(re);
 8910  40 
             recover(input,re);
 8911  40 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8912   
 
 8913   
         }
 8914   
 
 8915  0 
         finally {
 8916   
                 // do for sure before leaving
 8917  2710 
         }
 8918  2710 
         return retval;
 8919   
     }
 8920   
     // $ANTLR end "groupGraphPattern"
 8921   
 
 8922   
 
 8923  2598 
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 8924   
         Object tree;
 8925  2598 
         public Object getTree() { return tree; }
 8926   
     };
 8927   
 
 8928   
 
 8929   
     // $ANTLR start "groupGraphPatternSub"
 8930   
     // com\\googlecode\\sparkleg\\Sparql.g:287:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 8931   
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 8932  2598 
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 8933  2598 
         retval.start = input.LT(1);
 8934   
 
 8935   
 
 8936  2598 
         Object root_0 = null;
 8937   
 
 8938  2598 
         SparqlParser.triplesBlock_return triplesBlock201 =null;
 8939   
 
 8940  2598 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail202 =null;
 8941   
 
 8942  2598 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail203 =null;
 8943   
 
 8944   
 
 8945  2598 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 8946  2598 
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 8947   
         try {
 8948   
             // com\\googlecode\\sparkleg\\Sparql.g:288:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 8949  2598 
             int alt68=2;
 8950  2598 
             switch ( input.LA(1) ) {
 8951   
             case BLANK_NODE_LABEL:
 8952   
             case DECIMAL:
 8953   
             case DECIMAL_NEGATIVE:
 8954   
             case DECIMAL_POSITIVE:
 8955   
             case DOUBLE:
 8956   
             case DOUBLE_NEGATIVE:
 8957   
             case DOUBLE_POSITIVE:
 8958   
             case FALSE:
 8959   
             case INTEGER:
 8960   
             case INTEGER_NEGATIVE:
 8961   
             case INTEGER_POSITIVE:
 8962   
             case IRI_REF:
 8963   
             case OPEN_BRACE:
 8964   
             case OPEN_SQUARE_BRACKET:
 8965   
             case PNAME_LN:
 8966   
             case PNAME_NS:
 8967   
             case STRING_LITERAL1:
 8968   
             case STRING_LITERAL2:
 8969   
             case STRING_LITERAL_LONG1:
 8970   
             case STRING_LITERAL_LONG2:
 8971   
             case TRUE:
 8972   
             case VAR1:
 8973   
             case VAR2:
 8974   
                 {
 8975  2310 
                 alt68=1;
 8976   
                 }
 8977  2310 
                 break;
 8978   
             case BIND:
 8979   
             case FILTER:
 8980   
             case GRAPH:
 8981   
             case MINUS_KEYWORD:
 8982   
             case OPEN_CURLY_BRACE:
 8983   
             case OPTIONAL:
 8984   
             case SERVICE:
 8985   
                 {
 8986  288 
                 alt68=2;
 8987   
                 }
 8988  288 
                 break;
 8989   
             default:
 8990  0 
                 NoViableAltException nvae =
 8991   
                     new NoViableAltException("", 68, 0, input);
 8992   
 
 8993  0 
                 throw nvae;
 8994   
 
 8995   
             }
 8996   
 
 8997  2598 
             switch (alt68) {
 8998   
                 case 1 :
 8999   
                     // com\\googlecode\\sparkleg\\Sparql.g:288:7: triplesBlock ( groupGraphPatternSubDetail )*
 9000   
                     {
 9001  2310 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2341);
 9002  2310 
                     triplesBlock201=triplesBlock();
 9003   
 
 9004  2310 
                     state._fsp--;
 9005   
 
 9006  2310 
                     stream_triplesBlock.add(triplesBlock201.getTree());
 9007   
 
 9008   
                     // com\\googlecode\\sparkleg\\Sparql.g:288:20: ( groupGraphPatternSubDetail )*
 9009   
                     loop66:
 9010   
                     do {
 9011  3192 
                         int alt66=2;
 9012  3192 
                         switch ( input.LA(1) ) {
 9013   
                         case BIND:
 9014   
                         case FILTER:
 9015   
                         case GRAPH:
 9016   
                         case MINUS_KEYWORD:
 9017   
                         case OPEN_CURLY_BRACE:
 9018   
                         case OPTIONAL:
 9019   
                         case SERVICE:
 9020   
                             {
 9021  882 
                             alt66=1;
 9022   
                             }
 9023   
                             break;
 9024   
 
 9025   
                         }
 9026   
 
 9027  3192 
                         switch (alt66) {
 9028   
                             case 1 :
 9029   
                                 // com\\googlecode\\sparkleg\\Sparql.g:288:20: groupGraphPatternSubDetail
 9030   
                                 {
 9031  882 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2343);
 9032  882 
                                 groupGraphPatternSubDetail202=groupGraphPatternSubDetail();
 9033   
 
 9034  882 
                                 state._fsp--;
 9035   
 
 9036  882 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail202.getTree());
 9037   
 
 9038   
                                 }
 9039  882 
                                 break;
 9040   
 
 9041   
                             default :
 9042  2310 
                                 break loop66;
 9043   
                         }
 9044  882 
                     } while (true);
 9045   
 
 9046   
 
 9047   
                     // AST REWRITE
 9048   
                     // elements: groupGraphPatternSubDetail, triplesBlock
 9049   
                     // token labels:
 9050   
                     // rule labels: retval
 9051   
                     // token list labels:
 9052   
                     // rule list labels:
 9053   
                     // wildcard labels:
 9054  2310 
                     retval.tree = root_0;
 9055  2310 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9056   
 
 9057  2310 
                     root_0 = (Object)adaptor.nil();
 9058   
                     // 288:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9059   
                     {
 9060  2310 
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9061   
 
 9062   
                         // com\\googlecode\\sparkleg\\Sparql.g:288:64: ( groupGraphPatternSubDetail )*
 9063  3192 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9064  882 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9065   
 
 9066   
                         }
 9067  2310 
                         stream_groupGraphPatternSubDetail.reset();
 9068   
 
 9069   
                     }
 9070   
 
 9071   
 
 9072  2310 
                     retval.tree = root_0;
 9073   
 
 9074   
                     }
 9075  2310 
                     break;
 9076   
                 case 2 :
 9077   
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: ( groupGraphPatternSubDetail )+
 9078   
                     {
 9079   
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: ( groupGraphPatternSubDetail )+
 9080  288 
                     int cnt67=0;
 9081   
                     loop67:
 9082   
                     do {
 9083  650 
                         int alt67=2;
 9084  650 
                         switch ( input.LA(1) ) {
 9085   
                         case BIND:
 9086   
                         case FILTER:
 9087   
                         case GRAPH:
 9088   
                         case MINUS_KEYWORD:
 9089   
                         case OPEN_CURLY_BRACE:
 9090   
                         case OPTIONAL:
 9091   
                         case SERVICE:
 9092   
                             {
 9093  362 
                             alt67=1;
 9094   
                             }
 9095   
                             break;
 9096   
 
 9097   
                         }
 9098   
 
 9099  650 
                         switch (alt67) {
 9100   
                             case 1 :
 9101   
                                 // com\\googlecode\\sparkleg\\Sparql.g:289:7: groupGraphPatternSubDetail
 9102   
                                 {
 9103  362 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2359);
 9104  362 
                                 groupGraphPatternSubDetail203=groupGraphPatternSubDetail();
 9105   
 
 9106  362 
                                 state._fsp--;
 9107   
 
 9108  362 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail203.getTree());
 9109   
 
 9110   
                                 }
 9111  362 
                                 break;
 9112   
 
 9113   
                             default :
 9114  288 
                                 if ( cnt67 >= 1 ) break loop67;
 9115  0 
                                 EarlyExitException eee =
 9116   
                                     new EarlyExitException(67, input);
 9117  0 
                                 throw eee;
 9118   
                         }
 9119  362 
                         cnt67++;
 9120  362 
                     } while (true);
 9121   
 
 9122   
 
 9123   
                     // AST REWRITE
 9124   
                     // elements: groupGraphPatternSubDetail
 9125   
                     // token labels:
 9126   
                     // rule labels: retval
 9127   
                     // token list labels:
 9128   
                     // rule list labels:
 9129   
                     // wildcard labels:
 9130  288 
                     retval.tree = root_0;
 9131  288 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9132   
 
 9133  288 
                     root_0 = (Object)adaptor.nil();
 9134   
                     // 289:35: -> ( groupGraphPatternSubDetail )+
 9135   
                     {
 9136  288 
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9137  0 
                             throw new RewriteEarlyExitException();
 9138   
                         }
 9139  650 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9140  362 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9141   
 
 9142   
                         }
 9143  288 
                         stream_groupGraphPatternSubDetail.reset();
 9144   
 
 9145   
                     }
 9146   
 
 9147   
 
 9148  288 
                     retval.tree = root_0;
 9149   
 
 9150   
                     }
 9151   
                     break;
 9152   
 
 9153   
             }
 9154  2598 
             retval.stop = input.LT(-1);
 9155   
 
 9156   
 
 9157  2598 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9158  2598 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9159   
 
 9160   
         }
 9161  0 
         catch (RecognitionException re) {
 9162  0 
             reportError(re);
 9163  0 
             recover(input,re);
 9164  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9165   
 
 9166   
         }
 9167   
 
 9168  0 
         finally {
 9169   
                 // do for sure before leaving
 9170  2598 
         }
 9171  2598 
         return retval;
 9172   
     }
 9173   
     // $ANTLR end "groupGraphPatternSub"
 9174   
 
 9175   
 
 9176  1244 
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9177   
         Object tree;
 9178  1244 
         public Object getTree() { return tree; }
 9179   
     };
 9180   
 
 9181   
 
 9182   
     // $ANTLR start "groupGraphPatternSubDetail"
 9183   
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: groupGraphPatternSubDetail : graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9184   
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9185  1244 
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9186  1244 
         retval.start = input.LT(1);
 9187   
 
 9188   
 
 9189  1244 
         Object root_0 = null;
 9190   
 
 9191  1244 
         Token DOT205=null;
 9192  1244 
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples204 =null;
 9193   
 
 9194  1244 
         SparqlParser.triplesBlock_return triplesBlock206 =null;
 9195   
 
 9196   
 
 9197  1244 
         Object DOT205_tree=null;
 9198  1244 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9199  1244 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9200  1244 
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9201   
         try {
 9202   
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9203   
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: graphPatternNotTriples ( DOT )? ( triplesBlock )?
 9204   
             {
 9205  1244 
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2382);
 9206  1244 
             graphPatternNotTriples204=graphPatternNotTriples();
 9207   
 
 9208  1244 
             state._fsp--;
 9209   
 
 9210  1244 
             stream_graphPatternNotTriples.add(graphPatternNotTriples204.getTree());
 9211   
 
 9212   
             // com\\googlecode\\sparkleg\\Sparql.g:293:30: ( DOT )?
 9213  1244 
             int alt69=2;
 9214  1244 
             switch ( input.LA(1) ) {
 9215   
                 case DOT:
 9216   
                     {
 9217  196 
                     alt69=1;
 9218   
                     }
 9219   
                     break;
 9220   
             }
 9221   
 
 9222  1244 
             switch (alt69) {
 9223   
                 case 1 :
 9224   
                     // com\\googlecode\\sparkleg\\Sparql.g:293:30: DOT
 9225   
                     {
 9226  196 
                     DOT205=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2384);
 9227  196 
                     stream_DOT.add(DOT205);
 9228   
 
 9229   
 
 9230   
                     }
 9231   
                     break;
 9232   
 
 9233   
             }
 9234   
 
 9235   
 
 9236   
             // com\\googlecode\\sparkleg\\Sparql.g:293:35: ( triplesBlock )?
 9237  1244 
             int alt70=2;
 9238  1244 
             switch ( input.LA(1) ) {
 9239   
                 case BLANK_NODE_LABEL:
 9240   
                 case DECIMAL:
 9241   
                 case DECIMAL_NEGATIVE:
 9242   
                 case DECIMAL_POSITIVE:
 9243   
                 case DOUBLE:
 9244   
                 case DOUBLE_NEGATIVE:
 9245   
                 case DOUBLE_POSITIVE:
 9246   
                 case FALSE:
 9247   
                 case INTEGER:
 9248   
                 case INTEGER_NEGATIVE:
 9249   
                 case INTEGER_POSITIVE:
 9250   
                 case IRI_REF:
 9251   
                 case OPEN_BRACE:
 9252   
                 case OPEN_SQUARE_BRACKET:
 9253   
                 case PNAME_LN:
 9254   
                 case PNAME_NS:
 9255   
                 case STRING_LITERAL1:
 9256   
                 case STRING_LITERAL2:
 9257   
                 case STRING_LITERAL_LONG1:
 9258   
                 case STRING_LITERAL_LONG2:
 9259   
                 case TRUE:
 9260   
                 case VAR1:
 9261   
                 case VAR2:
 9262   
                     {
 9263  84 
                     alt70=1;
 9264   
                     }
 9265   
                     break;
 9266   
             }
 9267   
 
 9268  1244 
             switch (alt70) {
 9269   
                 case 1 :
 9270   
                     // com\\googlecode\\sparkleg\\Sparql.g:293:35: triplesBlock
 9271   
                     {
 9272  84 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2387);
 9273  84 
                     triplesBlock206=triplesBlock();
 9274   
 
 9275  84 
                     state._fsp--;
 9276   
 
 9277  84 
                     stream_triplesBlock.add(triplesBlock206.getTree());
 9278   
 
 9279   
                     }
 9280   
                     break;
 9281   
 
 9282   
             }
 9283   
 
 9284   
 
 9285   
             // AST REWRITE
 9286   
             // elements: triplesBlock, graphPatternNotTriples
 9287   
             // token labels:
 9288   
             // rule labels: retval
 9289   
             // token list labels:
 9290   
             // rule list labels:
 9291   
             // wildcard labels:
 9292  1244 
             retval.tree = root_0;
 9293  1244 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9294   
 
 9295  1244 
             root_0 = (Object)adaptor.nil();
 9296   
             // 293:49: -> graphPatternNotTriples ( triplesBlock )?
 9297   
             {
 9298  1244 
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9299   
 
 9300   
                 // com\\googlecode\\sparkleg\\Sparql.g:293:75: ( triplesBlock )?
 9301  1244 
                 if ( stream_triplesBlock.hasNext() ) {
 9302  84 
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9303   
 
 9304   
                 }
 9305  1244 
                 stream_triplesBlock.reset();
 9306   
 
 9307   
             }
 9308   
 
 9309   
 
 9310  1244 
             retval.tree = root_0;
 9311   
 
 9312   
             }
 9313   
 
 9314  1244 
             retval.stop = input.LT(-1);
 9315   
 
 9316   
 
 9317  1244 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9318  1244 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9319   
 
 9320   
         }
 9321  0 
         catch (RecognitionException re) {
 9322  0 
             reportError(re);
 9323  0 
             recover(input,re);
 9324  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9325   
 
 9326   
         }
 9327   
 
 9328  0 
         finally {
 9329   
                 // do for sure before leaving
 9330  1244 
         }
 9331  1244 
         return retval;
 9332   
     }
 9333   
     // $ANTLR end "groupGraphPatternSubDetail"
 9334   
 
 9335   
 
 9336  2394 
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9337   
         Object tree;
 9338  2394 
         public Object getTree() { return tree; }
 9339   
     };
 9340   
 
 9341   
 
 9342   
     // $ANTLR start "triplesBlock"
 9343   
     // com\\googlecode\\sparkleg\\Sparql.g:296:1: triplesBlock : triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ ;
 9344   
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9345  2394 
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9346  2394 
         retval.start = input.LT(1);
 9347   
 
 9348   
 
 9349  2394 
         Object root_0 = null;
 9350   
 
 9351  2394 
         Token DOT208=null;
 9352  2394 
         Token DOT210=null;
 9353  2394 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath207 =null;
 9354   
 
 9355  2394 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath209 =null;
 9356   
 
 9357   
 
 9358  2394 
         Object DOT208_tree=null;
 9359  2394 
         Object DOT210_tree=null;
 9360  2394 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9361  2394 
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9362   
         try {
 9363   
             // com\\googlecode\\sparkleg\\Sparql.g:297:5: ( triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ )
 9364   
             // com\\googlecode\\sparkleg\\Sparql.g:297:7: triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )?
 9365   
             {
 9366  2394 
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2412);
 9367  2394 
             triplesSameSubjectPath207=triplesSameSubjectPath();
 9368   
 
 9369  2394 
             state._fsp--;
 9370   
 
 9371  2394 
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath207.getTree());
 9372   
 
 9373   
             // com\\googlecode\\sparkleg\\Sparql.g:297:30: ( DOT triplesSameSubjectPath )*
 9374   
             loop71:
 9375   
             do {
 9376  2964 
                 int alt71=2;
 9377  2964 
                 switch ( input.LA(1) ) {
 9378   
                 case DOT:
 9379   
                     {
 9380  1484 
                     switch ( input.LA(2) ) {
 9381   
                     case BLANK_NODE_LABEL:
 9382   
                     case DECIMAL:
 9383   
                     case DECIMAL_NEGATIVE:
 9384   
                     case DECIMAL_POSITIVE:
 9385   
                     case DOUBLE:
 9386   
                     case DOUBLE_NEGATIVE:
 9387   
                     case DOUBLE_POSITIVE:
 9388   
                     case FALSE:
 9389   
                     case INTEGER:
 9390   
                     case INTEGER_NEGATIVE:
 9391   
                     case INTEGER_POSITIVE:
 9392   
                     case IRI_REF:
 9393   
                     case OPEN_BRACE:
 9394   
                     case OPEN_SQUARE_BRACKET:
 9395   
                     case PNAME_LN:
 9396   
                     case PNAME_NS:
 9397   
                     case STRING_LITERAL1:
 9398   
                     case STRING_LITERAL2:
 9399   
                     case STRING_LITERAL_LONG1:
 9400   
                     case STRING_LITERAL_LONG2:
 9401   
                     case TRUE:
 9402   
                     case VAR1:
 9403   
                     case VAR2:
 9404   
                         {
 9405  570 
                         alt71=1;
 9406   
                         }
 9407   
                         break;
 9408   
 
 9409   
                     }
 9410   
 
 9411   
                     }
 9412   
                     break;
 9413   
 
 9414   
                 }
 9415   
 
 9416  2964 
                 switch (alt71) {
 9417   
                     case 1 :
 9418   
                         // com\\googlecode\\sparkleg\\Sparql.g:297:31: DOT triplesSameSubjectPath
 9419   
                         {
 9420  570 
                         DOT208=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2415);
 9421  570 
                         stream_DOT.add(DOT208);
 9422   
 
 9423   
 
 9424  570 
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2417);
 9425  570 
                         triplesSameSubjectPath209=triplesSameSubjectPath();
 9426   
 
 9427  570 
                         state._fsp--;
 9428   
 
 9429  570 
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath209.getTree());
 9430   
 
 9431   
                         }
 9432  570 
                         break;
 9433   
 
 9434   
                     default :
 9435  2394 
                         break loop71;
 9436   
                 }
 9437  570 
             } while (true);
 9438   
 
 9439   
 
 9440   
             // com\\googlecode\\sparkleg\\Sparql.g:297:60: ( DOT )?
 9441  2394 
             int alt72=2;
 9442  2394 
             switch ( input.LA(1) ) {
 9443   
                 case DOT:
 9444   
                     {
 9445  914 
                     alt72=1;
 9446   
                     }
 9447   
                     break;
 9448   
             }
 9449   
 
 9450  2394 
             switch (alt72) {
 9451   
                 case 1 :
 9452   
                     // com\\googlecode\\sparkleg\\Sparql.g:297:60: DOT
 9453   
                     {
 9454  914 
                     DOT210=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2421);
 9455  914 
                     stream_DOT.add(DOT210);
 9456   
 
 9457   
 
 9458   
                     }
 9459   
                     break;
 9460   
 
 9461   
             }
 9462   
 
 9463   
 
 9464   
             // AST REWRITE
 9465   
             // elements: triplesSameSubjectPath
 9466   
             // token labels:
 9467   
             // rule labels: retval
 9468   
             // token list labels:
 9469   
             // rule list labels:
 9470   
             // wildcard labels:
 9471  2394 
             retval.tree = root_0;
 9472  2394 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9473   
 
 9474  2394 
             root_0 = (Object)adaptor.nil();
 9475   
             // 297:65: -> ( triplesSameSubjectPath )+
 9476   
             {
 9477  2394 
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9478  0 
                     throw new RewriteEarlyExitException();
 9479   
                 }
 9480  5358 
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9481  2964 
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9482   
 
 9483   
                 }
 9484  2394 
                 stream_triplesSameSubjectPath.reset();
 9485   
 
 9486   
             }
 9487   
 
 9488   
 
 9489  2394 
             retval.tree = root_0;
 9490   
 
 9491   
             }
 9492   
 
 9493  2394 
             retval.stop = input.LT(-1);
 9494   
 
 9495   
 
 9496  2394 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9497  2394 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9498   
 
 9499   
         }
 9500  0 
         catch (RecognitionException re) {
 9501  0 
             reportError(re);
 9502  0 
             recover(input,re);
 9503  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9504   
 
 9505   
         }
 9506   
 
 9507  0 
         finally {
 9508   
                 // do for sure before leaving
 9509  2394 
         }
 9510  2394 
         return retval;
 9511   
     }
 9512   
     // $ANTLR end "triplesBlock"
 9513   
 
 9514   
 
 9515  1244 
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9516   
         Object tree;
 9517  1244 
         public Object getTree() { return tree; }
 9518   
     };
 9519   
 
 9520   
 
 9521   
     // $ANTLR start "graphPatternNotTriples"
 9522   
     // com\\googlecode\\sparkleg\\Sparql.g:300:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9523   
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9524  1244 
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9525  1244 
         retval.start = input.LT(1);
 9526   
 
 9527   
 
 9528  1244 
         Object root_0 = null;
 9529   
 
 9530  1244 
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern211 =null;
 9531   
 
 9532  1244 
         SparqlParser.optionalGraphPattern_return optionalGraphPattern212 =null;
 9533   
 
 9534  1244 
         SparqlParser.minusGraphPattern_return minusGraphPattern213 =null;
 9535   
 
 9536  1244 
         SparqlParser.graphGraphPattern_return graphGraphPattern214 =null;
 9537   
 
 9538  1244 
         SparqlParser.serviceGraphPattern_return serviceGraphPattern215 =null;
 9539   
 
 9540  1244 
         SparqlParser.filter_return filter216 =null;
 9541   
 
 9542  1244 
         SparqlParser.bind_return bind217 =null;
 9543   
 
 9544   
 
 9545   
 
 9546   
         try {
 9547   
             // com\\googlecode\\sparkleg\\Sparql.g:301:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9548  1244 
             int alt73=7;
 9549  1244 
             switch ( input.LA(1) ) {
 9550   
             case OPEN_CURLY_BRACE:
 9551   
                 {
 9552  178 
                 alt73=1;
 9553   
                 }
 9554  178 
                 break;
 9555   
             case OPTIONAL:
 9556   
                 {
 9557  194 
                 alt73=2;
 9558   
                 }
 9559  194 
                 break;
 9560   
             case MINUS_KEYWORD:
 9561   
                 {
 9562  42 
                 alt73=3;
 9563   
                 }
 9564  42 
                 break;
 9565   
             case GRAPH:
 9566   
                 {
 9567  156 
                 alt73=4;
 9568   
                 }
 9569  156 
                 break;
 9570   
             case SERVICE:
 9571   
                 {
 9572  26 
                 alt73=5;
 9573   
                 }
 9574  26 
                 break;
 9575   
             case FILTER:
 9576   
                 {
 9577  598 
                 alt73=6;
 9578   
                 }
 9579  598 
                 break;
 9580   
             case BIND:
 9581   
                 {
 9582  50 
                 alt73=7;
 9583   
                 }
 9584  50 
                 break;
 9585   
             default:
 9586  0 
                 NoViableAltException nvae =
 9587   
                     new NoViableAltException("", 73, 0, input);
 9588   
 
 9589  0 
                 throw nvae;
 9590   
 
 9591   
             }
 9592   
 
 9593  1244 
             switch (alt73) {
 9594   
                 case 1 :
 9595   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:7: groupOrUnionGraphPattern
 9596   
                     {
 9597  178 
                     root_0 = (Object)adaptor.nil();
 9598   
 
 9599   
 
 9600  178 
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2444);
 9601  178 
                     groupOrUnionGraphPattern211=groupOrUnionGraphPattern();
 9602   
 
 9603  178 
                     state._fsp--;
 9604   
 
 9605  178 
                     adaptor.addChild(root_0, groupOrUnionGraphPattern211.getTree());
 9606   
 
 9607   
                     }
 9608  178 
                     break;
 9609   
                 case 2 :
 9610   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:34: optionalGraphPattern
 9611   
                     {
 9612  194 
                     root_0 = (Object)adaptor.nil();
 9613   
 
 9614   
 
 9615  194 
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2448);
 9616  194 
                     optionalGraphPattern212=optionalGraphPattern();
 9617   
 
 9618  194 
                     state._fsp--;
 9619   
 
 9620  194 
                     adaptor.addChild(root_0, optionalGraphPattern212.getTree());
 9621   
 
 9622   
                     }
 9623  194 
                     break;
 9624   
                 case 3 :
 9625   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:57: minusGraphPattern
 9626   
                     {
 9627  42 
                     root_0 = (Object)adaptor.nil();
 9628   
 
 9629   
 
 9630  42 
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2452);
 9631  42 
                     minusGraphPattern213=minusGraphPattern();
 9632   
 
 9633  42 
                     state._fsp--;
 9634   
 
 9635  42 
                     adaptor.addChild(root_0, minusGraphPattern213.getTree());
 9636   
 
 9637   
                     }
 9638  42 
                     break;
 9639   
                 case 4 :
 9640   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:77: graphGraphPattern
 9641   
                     {
 9642  156 
                     root_0 = (Object)adaptor.nil();
 9643   
 
 9644   
 
 9645  156 
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2456);
 9646  156 
                     graphGraphPattern214=graphGraphPattern();
 9647   
 
 9648  156 
                     state._fsp--;
 9649   
 
 9650  156 
                     adaptor.addChild(root_0, graphGraphPattern214.getTree());
 9651   
 
 9652   
                     }
 9653  156 
                     break;
 9654   
                 case 5 :
 9655   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:97: serviceGraphPattern
 9656   
                     {
 9657  26 
                     root_0 = (Object)adaptor.nil();
 9658   
 
 9659   
 
 9660  26 
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2460);
 9661  26 
                     serviceGraphPattern215=serviceGraphPattern();
 9662   
 
 9663  26 
                     state._fsp--;
 9664   
 
 9665  26 
                     adaptor.addChild(root_0, serviceGraphPattern215.getTree());
 9666   
 
 9667   
                     }
 9668  26 
                     break;
 9669   
                 case 6 :
 9670   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:119: filter
 9671   
                     {
 9672  598 
                     root_0 = (Object)adaptor.nil();
 9673   
 
 9674   
 
 9675  598 
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2464);
 9676  598 
                     filter216=filter();
 9677   
 
 9678  598 
                     state._fsp--;
 9679   
 
 9680  598 
                     adaptor.addChild(root_0, filter216.getTree());
 9681   
 
 9682   
                     }
 9683  598 
                     break;
 9684   
                 case 7 :
 9685   
                     // com\\googlecode\\sparkleg\\Sparql.g:301:128: bind
 9686   
                     {
 9687  50 
                     root_0 = (Object)adaptor.nil();
 9688   
 
 9689   
 
 9690  50 
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2468);
 9691  50 
                     bind217=bind();
 9692   
 
 9693  50 
                     state._fsp--;
 9694   
 
 9695  50 
                     adaptor.addChild(root_0, bind217.getTree());
 9696   
 
 9697   
                     }
 9698   
                     break;
 9699   
 
 9700   
             }
 9701  1244 
             retval.stop = input.LT(-1);
 9702   
 
 9703   
 
 9704  1244 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9705  1244 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9706   
 
 9707   
         }
 9708  0 
         catch (RecognitionException re) {
 9709  0 
             reportError(re);
 9710  0 
             recover(input,re);
 9711  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9712   
 
 9713   
         }
 9714   
 
 9715  0 
         finally {
 9716   
                 // do for sure before leaving
 9717  1244 
         }
 9718  1244 
         return retval;
 9719   
     }
 9720   
     // $ANTLR end "graphPatternNotTriples"
 9721   
 
 9722   
 
 9723  194 
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9724   
         Object tree;
 9725  194 
         public Object getTree() { return tree; }
 9726   
     };
 9727   
 
 9728   
 
 9729   
     // $ANTLR start "optionalGraphPattern"
 9730   
     // com\\googlecode\\sparkleg\\Sparql.g:304:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9731   
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9732  194 
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9733  194 
         retval.start = input.LT(1);
 9734   
 
 9735   
 
 9736  194 
         Object root_0 = null;
 9737   
 
 9738  194 
         Token OPTIONAL218=null;
 9739  194 
         SparqlParser.groupGraphPattern_return groupGraphPattern219 =null;
 9740   
 
 9741   
 
 9742  194 
         Object OPTIONAL218_tree=null;
 9743  194 
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9744  194 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9745   
         try {
 9746   
             // com\\googlecode\\sparkleg\\Sparql.g:305:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9747   
             // com\\googlecode\\sparkleg\\Sparql.g:305:7: OPTIONAL groupGraphPattern
 9748   
             {
 9749  194 
             OPTIONAL218=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2485);
 9750  194 
             stream_OPTIONAL.add(OPTIONAL218);
 9751   
 
 9752   
 
 9753  194 
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2487);
 9754  194 
             groupGraphPattern219=groupGraphPattern();
 9755   
 
 9756  194 
             state._fsp--;
 9757   
 
 9758  194 
             stream_groupGraphPattern.add(groupGraphPattern219.getTree());
 9759   
 
 9760   
             // AST REWRITE
 9761   
             // elements: OPTIONAL, groupGraphPattern
 9762   
             // token labels:
 9763   
             // rule labels: retval
 9764   
             // token list labels:
 9765   
             // rule list labels:
 9766   
             // wildcard labels:
 9767  194 
             retval.tree = root_0;
 9768  194 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9769   
 
 9770  194 
             root_0 = (Object)adaptor.nil();
 9771   
             // 305:34: -> ^( OPTIONAL groupGraphPattern )
 9772   
             {
 9773   
                 // com\\googlecode\\sparkleg\\Sparql.g:305:37: ^( OPTIONAL groupGraphPattern )
 9774   
                 {
 9775  194 
                 Object root_1 = (Object)adaptor.nil();
 9776  194 
                 root_1 = (Object)adaptor.becomeRoot(
 9777   
                 stream_OPTIONAL.nextNode()
 9778   
                 , root_1);
 9779   
 
 9780  194 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9781   
 
 9782  194 
                 adaptor.addChild(root_0, root_1);
 9783   
                 }
 9784   
 
 9785   
             }
 9786   
 
 9787   
 
 9788  194 
             retval.tree = root_0;
 9789   
 
 9790   
             }
 9791   
 
 9792  194 
             retval.stop = input.LT(-1);
 9793   
 
 9794   
 
 9795  194 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9796  194 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9797   
 
 9798   
         }
 9799  0 
         catch (RecognitionException re) {
 9800  0 
             reportError(re);
 9801  0 
             recover(input,re);
 9802  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9803   
 
 9804   
         }
 9805   
 
 9806  0 
         finally {
 9807   
                 // do for sure before leaving
 9808  194 
         }
 9809  194 
         return retval;
 9810   
     }
 9811   
     // $ANTLR end "optionalGraphPattern"
 9812   
 
 9813   
 
 9814  156 
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 9815   
         Object tree;
 9816  156 
         public Object getTree() { return tree; }
 9817   
     };
 9818   
 
 9819   
 
 9820   
     // $ANTLR start "graphGraphPattern"
 9821   
     // com\\googlecode\\sparkleg\\Sparql.g:308:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 9822   
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 9823  156 
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 9824  156 
         retval.start = input.LT(1);
 9825   
 
 9826   
 
 9827  156 
         Object root_0 = null;
 9828   
 
 9829  156 
         Token GRAPH220=null;
 9830  156 
         SparqlParser.varOrIRIref_return varOrIRIref221 =null;
 9831   
 
 9832  156 
         SparqlParser.groupGraphPattern_return groupGraphPattern222 =null;
 9833   
 
 9834   
 
 9835  156 
         Object GRAPH220_tree=null;
 9836  156 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 9837  156 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9838  156 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9839   
         try {
 9840   
             // com\\googlecode\\sparkleg\\Sparql.g:309:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 9841   
             // com\\googlecode\\sparkleg\\Sparql.g:309:7: GRAPH varOrIRIref groupGraphPattern
 9842   
             {
 9843  156 
             GRAPH220=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2512);
 9844  156 
             stream_GRAPH.add(GRAPH220);
 9845   
 
 9846   
 
 9847  156 
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2514);
 9848  156 
             varOrIRIref221=varOrIRIref();
 9849   
 
 9850  156 
             state._fsp--;
 9851   
 
 9852  156 
             stream_varOrIRIref.add(varOrIRIref221.getTree());
 9853   
 
 9854  156 
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2516);
 9855  156 
             groupGraphPattern222=groupGraphPattern();
 9856   
 
 9857  156 
             state._fsp--;
 9858   
 
 9859  156 
             stream_groupGraphPattern.add(groupGraphPattern222.getTree());
 9860   
 
 9861   
             // AST REWRITE
 9862   
             // elements: varOrIRIref, GRAPH, groupGraphPattern
 9863   
             // token labels:
 9864   
             // rule labels: retval
 9865   
             // token list labels:
 9866   
             // rule list labels:
 9867   
             // wildcard labels:
 9868  156 
             retval.tree = root_0;
 9869  156 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9870   
 
 9871  156 
             root_0 = (Object)adaptor.nil();
 9872   
             // 309:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 9873   
             {
 9874   
                 // com\\googlecode\\sparkleg\\Sparql.g:309:46: ^( GRAPH varOrIRIref groupGraphPattern )
 9875   
                 {
 9876  156 
                 Object root_1 = (Object)adaptor.nil();
 9877  156 
                 root_1 = (Object)adaptor.becomeRoot(
 9878   
                 stream_GRAPH.nextNode()
 9879   
                 , root_1);
 9880   
 
 9881  156 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 9882   
 
 9883  156 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9884   
 
 9885  156 
                 adaptor.addChild(root_0, root_1);
 9886   
                 }
 9887   
 
 9888   
             }
 9889   
 
 9890   
 
 9891  156 
             retval.tree = root_0;
 9892   
 
 9893   
             }
 9894   
 
 9895  156 
             retval.stop = input.LT(-1);
 9896   
 
 9897   
 
 9898  156 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9899  156 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9900   
 
 9901   
         }
 9902  0 
         catch (RecognitionException re) {
 9903  0 
             reportError(re);
 9904  0 
             recover(input,re);
 9905  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9906   
 
 9907   
         }
 9908   
 
 9909  0 
         finally {
 9910   
                 // do for sure before leaving
 9911  156 
         }
 9912  156 
         return retval;
 9913   
     }
 9914   
     // $ANTLR end "graphGraphPattern"
 9915   
 
 9916   
 
 9917  26 
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 9918   
         Object tree;
 9919  26 
         public Object getTree() { return tree; }
 9920   
     };
 9921   
 
 9922   
 
 9923   
     // $ANTLR start "serviceGraphPattern"
 9924   
     // com\\googlecode\\sparkleg\\Sparql.g:312:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 9925   
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 9926  26 
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 9927  26 
         retval.start = input.LT(1);
 9928   
 
 9929   
 
 9930  26 
         Object root_0 = null;
 9931   
 
 9932  26 
         Token SERVICE223=null;
 9933  26 
         Token SILENT224=null;
 9934  26 
         SparqlParser.varOrIRIref_return varOrIRIref225 =null;
 9935   
 
 9936  26 
         SparqlParser.groupGraphPattern_return groupGraphPattern226 =null;
 9937   
 
 9938   
 
 9939  26 
         Object SERVICE223_tree=null;
 9940  26 
         Object SILENT224_tree=null;
 9941  26 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 9942  26 
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 9943  26 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9944  26 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9945   
         try {
 9946   
             // com\\googlecode\\sparkleg\\Sparql.g:313:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 9947   
             // com\\googlecode\\sparkleg\\Sparql.g:313:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 9948   
             {
 9949  26 
             SERVICE223=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2543);
 9950  26 
             stream_SERVICE.add(SERVICE223);
 9951   
 
 9952   
 
 9953   
             // com\\googlecode\\sparkleg\\Sparql.g:313:15: ( SILENT )?
 9954  26 
             int alt74=2;
 9955  26 
             switch ( input.LA(1) ) {
 9956   
                 case SILENT:
 9957   
                     {
 9958  6 
                     alt74=1;
 9959   
                     }
 9960   
                     break;
 9961   
             }
 9962   
 
 9963  26 
             switch (alt74) {
 9964   
                 case 1 :
 9965   
                     // com\\googlecode\\sparkleg\\Sparql.g:313:15: SILENT
 9966   
                     {
 9967  6 
                     SILENT224=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2545);
 9968  6 
                     stream_SILENT.add(SILENT224);
 9969   
 
 9970   
 
 9971   
                     }
 9972   
                     break;
 9973   
 
 9974   
             }
 9975   
 
 9976   
 
 9977  26 
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2548);
 9978  26 
             varOrIRIref225=varOrIRIref();
 9979   
 
 9980  26 
             state._fsp--;
 9981   
 
 9982  26 
             stream_varOrIRIref.add(varOrIRIref225.getTree());
 9983   
 
 9984  26 
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2550);
 9985  26 
             groupGraphPattern226=groupGraphPattern();
 9986   
 
 9987  26 
             state._fsp--;
 9988   
 
 9989  26 
             stream_groupGraphPattern.add(groupGraphPattern226.getTree());
 9990   
 
 9991   
             // AST REWRITE
 9992   
             // elements: SERVICE, groupGraphPattern, SILENT, varOrIRIref
 9993   
             // token labels:
 9994   
             // rule labels: retval
 9995   
             // token list labels:
 9996   
             // rule list labels:
 9997   
             // wildcard labels:
 9998  26 
             retval.tree = root_0;
 9999  26 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10000   
 
 10001  26 
             root_0 = (Object)adaptor.nil();
 10002   
             // 313:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10003   
             {
 10004   
                 // com\\googlecode\\sparkleg\\Sparql.g:313:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10005   
                 {
 10006  26 
                 Object root_1 = (Object)adaptor.nil();
 10007  26 
                 root_1 = (Object)adaptor.becomeRoot(
 10008   
                 stream_SERVICE.nextNode()
 10009   
                 , root_1);
 10010   
 
 10011   
                 // com\\googlecode\\sparkleg\\Sparql.g:313:66: ( SILENT )?
 10012  26 
                 if ( stream_SILENT.hasNext() ) {
 10013  6 
                     adaptor.addChild(root_1,
 10014   
                     stream_SILENT.nextNode()
 10015   
                     );
 10016   
 
 10017   
                 }
 10018  26 
                 stream_SILENT.reset();
 10019   
 
 10020  26 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10021   
 
 10022  26 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10023   
 
 10024  26 
                 adaptor.addChild(root_0, root_1);
 10025   
                 }
 10026   
 
 10027   
             }
 10028   
 
 10029   
 
 10030  26 
             retval.tree = root_0;
 10031   
 
 10032   
             }
 10033   
 
 10034  26 
             retval.stop = input.LT(-1);
 10035   
 
 10036   
 
 10037  26 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10038  26 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10039   
 
 10040   
         }
 10041  0 
         catch (RecognitionException re) {
 10042  0 
             reportError(re);
 10043  0 
             recover(input,re);
 10044  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10045   
 
 10046   
         }
 10047   
 
 10048  0 
         finally {
 10049   
                 // do for sure before leaving
 10050  26 
         }
 10051  26 
         return retval;
 10052   
     }
 10053   
     // $ANTLR end "serviceGraphPattern"
 10054   
 
 10055   
 
 10056  50 
     public static class bind_return extends ParserRuleReturnScope {
 10057   
         Object tree;
 10058  50 
         public Object getTree() { return tree; }
 10059   
     };
 10060   
 
 10061   
 
 10062   
     // $ANTLR start "bind"
 10063   
     // com\\googlecode\\sparkleg\\Sparql.g:316:1: bind : BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) ;
 10064   
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10065  50 
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10066  50 
         retval.start = input.LT(1);
 10067   
 
 10068   
 
 10069  50 
         Object root_0 = null;
 10070   
 
 10071  50 
         Token BIND227=null;
 10072  50 
         Token OPEN_BRACE228=null;
 10073  50 
         Token AS230=null;
 10074  50 
         Token CLOSE_BRACE232=null;
 10075  50 
         SparqlParser.expression_return expression229 =null;
 10076   
 
 10077  50 
         SparqlParser.var_return var231 =null;
 10078   
 
 10079   
 
 10080  50 
         Object BIND227_tree=null;
 10081  50 
         Object OPEN_BRACE228_tree=null;
 10082  50 
         Object AS230_tree=null;
 10083  50 
         Object CLOSE_BRACE232_tree=null;
 10084  50 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10085  50 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10086  50 
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10087  50 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10088  50 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10089  50 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10090   
         try {
 10091   
             // com\\googlecode\\sparkleg\\Sparql.g:317:5: ( BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) )
 10092   
             // com\\googlecode\\sparkleg\\Sparql.g:317:7: BIND OPEN_BRACE expression AS var CLOSE_BRACE
 10093   
             {
 10094  50 
             BIND227=(Token)match(input,BIND,FOLLOW_BIND_in_bind2584);
 10095  50 
             stream_BIND.add(BIND227);
 10096   
 
 10097   
 
 10098  50 
             OPEN_BRACE228=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bind2586);
 10099  50 
             stream_OPEN_BRACE.add(OPEN_BRACE228);
 10100   
 
 10101   
 
 10102  50 
             pushFollow(FOLLOW_expression_in_bind2588);
 10103  50 
             expression229=expression();
 10104   
 
 10105  50 
             state._fsp--;
 10106   
 
 10107  50 
             stream_expression.add(expression229.getTree());
 10108   
 
 10109  50 
             AS230=(Token)match(input,AS,FOLLOW_AS_in_bind2590);
 10110  50 
             stream_AS.add(AS230);
 10111   
 
 10112   
 
 10113  50 
             pushFollow(FOLLOW_var_in_bind2592);
 10114  50 
             var231=var();
 10115   
 
 10116  50 
             state._fsp--;
 10117   
 
 10118  50 
             stream_var.add(var231.getTree());
 10119   
 
 10120  50 
             CLOSE_BRACE232=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bind2594);
 10121  50 
             stream_CLOSE_BRACE.add(CLOSE_BRACE232);
 10122   
 
 10123   
 
 10124   
             // AST REWRITE
 10125   
             // elements: AS, expression, var, BIND
 10126   
             // token labels:
 10127   
             // rule labels: retval
 10128   
             // token list labels:
 10129   
             // rule list labels:
 10130   
             // wildcard labels:
 10131  50 
             retval.tree = root_0;
 10132  50 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10133   
 
 10134  50 
             root_0 = (Object)adaptor.nil();
 10135   
             // 317:53: -> ^( BIND expression ^( AS var ) )
 10136   
             {
 10137   
                 // com\\googlecode\\sparkleg\\Sparql.g:317:56: ^( BIND expression ^( AS var ) )
 10138   
                 {
 10139  50 
                 Object root_1 = (Object)adaptor.nil();
 10140  50 
                 root_1 = (Object)adaptor.becomeRoot(
 10141   
                 stream_BIND.nextNode()
 10142   
                 , root_1);
 10143   
 
 10144  50 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10145   
 
 10146   
                 // com\\googlecode\\sparkleg\\Sparql.g:317:74: ^( AS var )
 10147   
                 {
 10148  50 
                 Object root_2 = (Object)adaptor.nil();
 10149  50 
                 root_2 = (Object)adaptor.becomeRoot(
 10150   
                 stream_AS.nextNode()
 10151   
                 , root_2);
 10152   
 
 10153  50 
                 adaptor.addChild(root_2, stream_var.nextTree());
 10154   
 
 10155  50 
                 adaptor.addChild(root_1, root_2);
 10156   
                 }
 10157   
 
 10158  50 
                 adaptor.addChild(root_0, root_1);
 10159   
                 }
 10160   
 
 10161   
             }
 10162   
 
 10163   
 
 10164  50 
             retval.tree = root_0;
 10165   
 
 10166   
             }
 10167   
 
 10168  50 
             retval.stop = input.LT(-1);
 10169   
 
 10170   
 
 10171  50 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10172  50 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10173   
 
 10174   
         }
 10175  0 
         catch (RecognitionException re) {
 10176  0 
             reportError(re);
 10177  0 
             recover(input,re);
 10178  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10179   
 
 10180   
         }
 10181   
 
 10182  0 
         finally {
 10183   
                 // do for sure before leaving
 10184  50 
         }
 10185  50 
         return retval;
 10186   
     }
 10187   
     // $ANTLR end "bind"
 10188   
 
 10189   
 
 10190  42 
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10191   
         Object tree;
 10192  42 
         public Object getTree() { return tree; }
 10193   
     };
 10194   
 
 10195   
 
 10196   
     // $ANTLR start "minusGraphPattern"
 10197   
     // com\\googlecode\\sparkleg\\Sparql.g:320:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10198   
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10199  42 
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10200  42 
         retval.start = input.LT(1);
 10201   
 
 10202   
 
 10203  42 
         Object root_0 = null;
 10204   
 
 10205  42 
         Token MINUS_KEYWORD233=null;
 10206  42 
         SparqlParser.groupGraphPattern_return groupGraphPattern234 =null;
 10207   
 
 10208   
 
 10209  42 
         Object MINUS_KEYWORD233_tree=null;
 10210  42 
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10211  42 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10212   
         try {
 10213   
             // com\\googlecode\\sparkleg\\Sparql.g:321:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10214   
             // com\\googlecode\\sparkleg\\Sparql.g:321:7: MINUS_KEYWORD groupGraphPattern
 10215   
             {
 10216  42 
             MINUS_KEYWORD233=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2631);
 10217  42 
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD233);
 10218   
 
 10219   
 
 10220  42 
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2633);
 10221  42 
             groupGraphPattern234=groupGraphPattern();
 10222   
 
 10223  42 
             state._fsp--;
 10224   
 
 10225  42 
             stream_groupGraphPattern.add(groupGraphPattern234.getTree());
 10226   
 
 10227   
             // AST REWRITE
 10228   
             // elements: MINUS_KEYWORD, groupGraphPattern
 10229   
             // token labels:
 10230   
             // rule labels: retval
 10231   
             // token list labels:
 10232   
             // rule list labels:
 10233   
             // wildcard labels:
 10234  42 
             retval.tree = root_0;
 10235  42 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10236   
 
 10237  42 
             root_0 = (Object)adaptor.nil();
 10238   
             // 321:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10239   
             {
 10240   
                 // com\\googlecode\\sparkleg\\Sparql.g:321:42: ^( MINUS_KEYWORD groupGraphPattern )
 10241   
                 {
 10242  42 
                 Object root_1 = (Object)adaptor.nil();
 10243  42 
                 root_1 = (Object)adaptor.becomeRoot(
 10244   
                 stream_MINUS_KEYWORD.nextNode()
 10245   
                 , root_1);
 10246   
 
 10247  42 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10248   
 
 10249  42 
                 adaptor.addChild(root_0, root_1);
 10250   
                 }
 10251   
 
 10252   
             }
 10253   
 
 10254   
 
 10255  42 
             retval.tree = root_0;
 10256   
 
 10257   
             }
 10258   
 
 10259  42 
             retval.stop = input.LT(-1);
 10260   
 
 10261   
 
 10262  42 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10263  42 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10264   
 
 10265   
         }
 10266  0 
         catch (RecognitionException re) {
 10267  0 
             reportError(re);
 10268  0 
             recover(input,re);
 10269  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10270   
 
 10271   
         }
 10272   
 
 10273  0 
         finally {
 10274   
                 // do for sure before leaving
 10275  42 
         }
 10276  42 
         return retval;
 10277   
     }
 10278   
     // $ANTLR end "minusGraphPattern"
 10279   
 
 10280   
 
 10281  178 
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10282   
         Object tree;
 10283  178 
         public Object getTree() { return tree; }
 10284   
     };
 10285   
 
 10286   
 
 10287   
     // $ANTLR start "groupOrUnionGraphPattern"
 10288   
     // com\\googlecode\\sparkleg\\Sparql.g:324:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10289   
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10290  178 
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10291  178 
         retval.start = input.LT(1);
 10292   
 
 10293   
 
 10294  178 
         Object root_0 = null;
 10295   
 
 10296  178 
         Token UNION235=null;
 10297  178 
         SparqlParser.groupGraphPattern_return g1 =null;
 10298   
 
 10299  178 
         SparqlParser.groupGraphPattern_return g2 =null;
 10300   
 
 10301   
 
 10302  178 
         Object UNION235_tree=null;
 10303  178 
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10304  178 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10305   
         try {
 10306   
             // com\\googlecode\\sparkleg\\Sparql.g:325:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10307   
             // com\\googlecode\\sparkleg\\Sparql.g:325:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10308   
             {
 10309   
             // com\\googlecode\\sparkleg\\Sparql.g:325:7: (g1= groupGraphPattern -> $g1)
 10310   
             // com\\googlecode\\sparkleg\\Sparql.g:325:8: g1= groupGraphPattern
 10311   
             {
 10312  178 
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2661);
 10313  178 
             g1=groupGraphPattern();
 10314   
 
 10315  178 
             state._fsp--;
 10316   
 
 10317  178 
             stream_groupGraphPattern.add(g1.getTree());
 10318   
 
 10319   
             // AST REWRITE
 10320   
             // elements: g1
 10321   
             // token labels:
 10322   
             // rule labels: retval, g1
 10323   
             // token list labels:
 10324   
             // rule list labels:
 10325   
             // wildcard labels:
 10326  178 
             retval.tree = root_0;
 10327  178 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10328  178 
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10329   
 
 10330  178 
             root_0 = (Object)adaptor.nil();
 10331   
             // 325:28: -> $g1
 10332   
             {
 10333  178 
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10334   
 
 10335   
             }
 10336   
 
 10337   
 
 10338  178 
             retval.tree = root_0;
 10339   
 
 10340   
             }
 10341   
 
 10342   
 
 10343   
             // com\\googlecode\\sparkleg\\Sparql.g:325:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10344   
             loop75:
 10345   
             do {
 10346  274 
                 int alt75=2;
 10347  274 
                 switch ( input.LA(1) ) {
 10348   
                 case UNION:
 10349   
                     {
 10350  96 
                     alt75=1;
 10351   
                     }
 10352   
                     break;
 10353   
 
 10354   
                 }
 10355   
 
 10356  274 
                 switch (alt75) {
 10357   
                     case 1 :
 10358   
                         // com\\googlecode\\sparkleg\\Sparql.g:325:36: ( UNION g2= groupGraphPattern )
 10359   
                         {
 10360   
                         // com\\googlecode\\sparkleg\\Sparql.g:325:36: ( UNION g2= groupGraphPattern )
 10361   
                         // com\\googlecode\\sparkleg\\Sparql.g:325:37: UNION g2= groupGraphPattern
 10362   
                         {
 10363  96 
                         UNION235=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2669);
 10364  96 
                         stream_UNION.add(UNION235);
 10365   
 
 10366   
 
 10367  96 
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2673);
 10368  96 
                         g2=groupGraphPattern();
 10369   
 
 10370  96 
                         state._fsp--;
 10371   
 
 10372  96 
                         stream_groupGraphPattern.add(g2.getTree());
 10373   
 
 10374   
                         }
 10375   
 
 10376   
 
 10377   
                         // AST REWRITE
 10378   
                         // elements: UNION, g2, groupOrUnionGraphPattern
 10379   
                         // token labels:
 10380   
                         // rule labels: retval, g2
 10381   
                         // token list labels:
 10382   
                         // rule list labels:
 10383   
                         // wildcard labels:
 10384  96 
                         retval.tree = root_0;
 10385  96 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10386  96 
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10387   
 
 10388  96 
                         root_0 = (Object)adaptor.nil();
 10389   
                         // 325:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10390   
                         {
 10391   
                             // com\\googlecode\\sparkleg\\Sparql.g:325:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10392   
                             {
 10393  96 
                             Object root_1 = (Object)adaptor.nil();
 10394  96 
                             root_1 = (Object)adaptor.becomeRoot(
 10395   
                             stream_UNION.nextNode()
 10396   
                             , root_1);
 10397   
 
 10398  96 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10399   
 
 10400  96 
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10401   
 
 10402  96 
                             adaptor.addChild(root_0, root_1);
 10403   
                             }
 10404   
 
 10405   
                         }
 10406   
 
 10407   
 
 10408  96 
                         retval.tree = root_0;
 10409   
 
 10410   
                         }
 10411  96 
                         break;
 10412   
 
 10413   
                     default :
 10414  178 
                         break loop75;
 10415   
                 }
 10416  96 
             } while (true);
 10417   
 
 10418   
 
 10419   
             }
 10420   
 
 10421  178 
             retval.stop = input.LT(-1);
 10422   
 
 10423   
 
 10424  178 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10425  178 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10426   
 
 10427   
         }
 10428  0 
         catch (RecognitionException re) {
 10429  0 
             reportError(re);
 10430  0 
             recover(input,re);
 10431  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10432   
 
 10433   
         }
 10434   
 
 10435  0 
         finally {
 10436   
                 // do for sure before leaving
 10437  178 
         }
 10438  178 
         return retval;
 10439   
     }
 10440   
     // $ANTLR end "groupOrUnionGraphPattern"
 10441   
 
 10442   
 
 10443  598 
     public static class filter_return extends ParserRuleReturnScope {
 10444   
         Object tree;
 10445  598 
         public Object getTree() { return tree; }
 10446   
     };
 10447   
 
 10448   
 
 10449   
     // $ANTLR start "filter"
 10450   
     // com\\googlecode\\sparkleg\\Sparql.g:328:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10451   
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10452  598 
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10453  598 
         retval.start = input.LT(1);
 10454   
 
 10455   
 
 10456  598 
         Object root_0 = null;
 10457   
 
 10458  598 
         Token FILTER236=null;
 10459  598 
         SparqlParser.constraint_return constraint237 =null;
 10460   
 
 10461   
 
 10462  598 
         Object FILTER236_tree=null;
 10463  598 
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10464  598 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10465   
         try {
 10466   
             // com\\googlecode\\sparkleg\\Sparql.g:329:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10467   
             // com\\googlecode\\sparkleg\\Sparql.g:329:7: FILTER constraint
 10468   
             {
 10469  598 
             FILTER236=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2705);
 10470  598 
             stream_FILTER.add(FILTER236);
 10471   
 
 10472   
 
 10473  598 
             pushFollow(FOLLOW_constraint_in_filter2707);
 10474  598 
             constraint237=constraint();
 10475   
 
 10476  598 
             state._fsp--;
 10477   
 
 10478  598 
             stream_constraint.add(constraint237.getTree());
 10479   
 
 10480   
             // AST REWRITE
 10481   
             // elements: FILTER, constraint
 10482   
             // token labels:
 10483   
             // rule labels: retval
 10484   
             // token list labels:
 10485   
             // rule list labels:
 10486   
             // wildcard labels:
 10487  598 
             retval.tree = root_0;
 10488  598 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10489   
 
 10490  598 
             root_0 = (Object)adaptor.nil();
 10491   
             // 329:25: -> ^( FILTER constraint )
 10492   
             {
 10493   
                 // com\\googlecode\\sparkleg\\Sparql.g:329:28: ^( FILTER constraint )
 10494   
                 {
 10495  598 
                 Object root_1 = (Object)adaptor.nil();
 10496  598 
                 root_1 = (Object)adaptor.becomeRoot(
 10497   
                 stream_FILTER.nextNode()
 10498   
                 , root_1);
 10499   
 
 10500  598 
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10501   
 
 10502  598 
                 adaptor.addChild(root_0, root_1);
 10503   
                 }
 10504   
 
 10505   
             }
 10506   
 
 10507   
 
 10508  598 
             retval.tree = root_0;
 10509   
 
 10510   
             }
 10511   
 
 10512  598 
             retval.stop = input.LT(-1);
 10513   
 
 10514   
 
 10515  598 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10516  598 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10517   
 
 10518   
         }
 10519  0 
         catch (RecognitionException re) {
 10520  0 
             reportError(re);
 10521  0 
             recover(input,re);
 10522  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10523   
 
 10524   
         }
 10525   
 
 10526  0 
         finally {
 10527   
                 // do for sure before leaving
 10528  598 
         }
 10529  598 
         return retval;
 10530   
     }
 10531   
     // $ANTLR end "filter"
 10532   
 
 10533   
 
 10534  626 
     public static class constraint_return extends ParserRuleReturnScope {
 10535   
         Object tree;
 10536  626 
         public Object getTree() { return tree; }
 10537   
     };
 10538   
 
 10539   
 
 10540   
     // $ANTLR start "constraint"
 10541   
     // com\\googlecode\\sparkleg\\Sparql.g:332:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10542   
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10543  626 
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10544  626 
         retval.start = input.LT(1);
 10545   
 
 10546   
 
 10547  626 
         Object root_0 = null;
 10548   
 
 10549  626 
         SparqlParser.brackettedExpression_return brackettedExpression238 =null;
 10550   
 
 10551  626 
         SparqlParser.builtInCall_return builtInCall239 =null;
 10552   
 
 10553  626 
         SparqlParser.functionCall_return functionCall240 =null;
 10554   
 
 10555   
 
 10556   
 
 10557   
         try {
 10558   
             // com\\googlecode\\sparkleg\\Sparql.g:333:5: ( brackettedExpression | builtInCall | functionCall )
 10559  626 
             int alt76=3;
 10560  626 
             switch ( input.LA(1) ) {
 10561   
             case OPEN_BRACE:
 10562   
                 {
 10563  458 
                 alt76=1;
 10564   
                 }
 10565  458 
                 break;
 10566   
             case ABS:
 10567   
             case BNODE:
 10568   
             case BOUND:
 10569   
             case CEIL:
 10570   
             case COALESCE:
 10571   
             case CONCAT:
 10572   
             case CONTAINS:
 10573   
             case DATATYPE:
 10574   
             case DAY:
 10575   
             case ENCODE_FOR_URI:
 10576   
             case EXISTS:
 10577   
             case FLOOR:
 10578   
             case HOURS:
 10579   
             case IF:
 10580   
             case IRI:
 10581   
             case ISBLANK:
 10582   
             case ISIRI:
 10583   
             case ISLITERAL:
 10584   
             case ISNUMERIC:
 10585   
             case ISURI:
 10586   
             case LANG:
 10587   
             case LANGMATCHES:
 10588   
             case LCASE:
 10589   
             case MD5:
 10590   
             case MINUTES:
 10591   
             case MONTH:
 10592   
             case NOT:
 10593   
             case NOW:
 10594   
             case RAND:
 10595   
             case REGEX:
 10596   
             case REPLACE:
 10597   
             case ROUND:
 10598   
             case SAMETERM:
 10599   
             case SECONDS:
 10600   
             case SHA1:
 10601   
             case SHA224:
 10602   
             case SHA256:
 10603   
             case SHA384:
 10604   
             case SHA512:
 10605   
             case STR:
 10606   
             case STRAFTER:
 10607   
             case STRBEFORE:
 10608   
             case STRDT:
 10609   
             case STRENDS:
 10610   
             case STRLANG:
 10611   
             case STRLEN:
 10612   
             case STRSTARTS:
 10613   
             case SUBSTR:
 10614   
             case TIMEZONE:
 10615   
             case TZ:
 10616   
             case UCASE:
 10617   
             case URI:
 10618   
             case YEAR:
 10619   
                 {
 10620  158 
                 alt76=2;
 10621   
                 }
 10622  158 
                 break;
 10623   
             case IRI_REF:
 10624   
             case PNAME_LN:
 10625   
             case PNAME_NS:
 10626   
                 {
 10627  8 
                 alt76=3;
 10628   
                 }
 10629  8 
                 break;
 10630   
             default:
 10631  2 
                 NoViableAltException nvae =
 10632   
                     new NoViableAltException("", 76, 0, input);
 10633   
 
 10634  2 
                 throw nvae;
 10635   
 
 10636   
             }
 10637   
 
 10638  624 
             switch (alt76) {
 10639   
                 case 1 :
 10640   
                     // com\\googlecode\\sparkleg\\Sparql.g:333:7: brackettedExpression
 10641   
                     {
 10642  458 
                     root_0 = (Object)adaptor.nil();
 10643   
 
 10644   
 
 10645  458 
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2732);
 10646  458 
                     brackettedExpression238=brackettedExpression();
 10647   
 
 10648  458 
                     state._fsp--;
 10649   
 
 10650  458 
                     adaptor.addChild(root_0, brackettedExpression238.getTree());
 10651   
 
 10652   
                     }
 10653  458 
                     break;
 10654   
                 case 2 :
 10655   
                     // com\\googlecode\\sparkleg\\Sparql.g:334:7: builtInCall
 10656   
                     {
 10657  158 
                     root_0 = (Object)adaptor.nil();
 10658   
 
 10659   
 
 10660  158 
                     pushFollow(FOLLOW_builtInCall_in_constraint2740);
 10661  158 
                     builtInCall239=builtInCall();
 10662   
 
 10663  158 
                     state._fsp--;
 10664   
 
 10665  158 
                     adaptor.addChild(root_0, builtInCall239.getTree());
 10666   
 
 10667   
                     }
 10668  158 
                     break;
 10669   
                 case 3 :
 10670   
                     // com\\googlecode\\sparkleg\\Sparql.g:335:7: functionCall
 10671   
                     {
 10672  8 
                     root_0 = (Object)adaptor.nil();
 10673   
 
 10674   
 
 10675  8 
                     pushFollow(FOLLOW_functionCall_in_constraint2748);
 10676  8 
                     functionCall240=functionCall();
 10677   
 
 10678  8 
                     state._fsp--;
 10679   
 
 10680  8 
                     adaptor.addChild(root_0, functionCall240.getTree());
 10681   
 
 10682   
                     }
 10683   
                     break;
 10684   
 
 10685   
             }
 10686  624 
             retval.stop = input.LT(-1);
 10687   
 
 10688   
 
 10689  624 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10690  624 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10691   
 
 10692   
         }
 10693  2 
         catch (RecognitionException re) {
 10694  2 
             reportError(re);
 10695  2 
             recover(input,re);
 10696  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10697   
 
 10698   
         }
 10699   
 
 10700  0 
         finally {
 10701   
                 // do for sure before leaving
 10702  626 
         }
 10703  626 
         return retval;
 10704   
     }
 10705   
     // $ANTLR end "constraint"
 10706   
 
 10707   
 
 10708  8 
     public static class functionCall_return extends ParserRuleReturnScope {
 10709   
         Object tree;
 10710  8 
         public Object getTree() { return tree; }
 10711   
     };
 10712   
 
 10713   
 
 10714   
     // $ANTLR start "functionCall"
 10715   
     // com\\googlecode\\sparkleg\\Sparql.g:338:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10716   
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10717  8 
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10718  8 
         retval.start = input.LT(1);
 10719   
 
 10720   
 
 10721  8 
         Object root_0 = null;
 10722   
 
 10723  8 
         SparqlParser.iriRef_return iriRef241 =null;
 10724   
 
 10725  8 
         SparqlParser.argList_return argList242 =null;
 10726   
 
 10727   
 
 10728  8 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10729  8 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10730   
         try {
 10731   
             // com\\googlecode\\sparkleg\\Sparql.g:339:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10732   
             // com\\googlecode\\sparkleg\\Sparql.g:339:7: iriRef argList
 10733   
             {
 10734  8 
             pushFollow(FOLLOW_iriRef_in_functionCall2765);
 10735  8 
             iriRef241=iriRef();
 10736   
 
 10737  8 
             state._fsp--;
 10738   
 
 10739  8 
             stream_iriRef.add(iriRef241.getTree());
 10740   
 
 10741  8 
             pushFollow(FOLLOW_argList_in_functionCall2767);
 10742  8 
             argList242=argList();
 10743   
 
 10744  8 
             state._fsp--;
 10745   
 
 10746  8 
             stream_argList.add(argList242.getTree());
 10747   
 
 10748   
             // AST REWRITE
 10749   
             // elements: iriRef, argList
 10750   
             // token labels:
 10751   
             // rule labels: retval
 10752   
             // token list labels:
 10753   
             // rule list labels:
 10754   
             // wildcard labels:
 10755  8 
             retval.tree = root_0;
 10756  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10757   
 
 10758  8 
             root_0 = (Object)adaptor.nil();
 10759   
             // 339:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10760   
             {
 10761   
                 // com\\googlecode\\sparkleg\\Sparql.g:339:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10762   
                 {
 10763  8 
                 Object root_1 = (Object)adaptor.nil();
 10764  8 
                 root_1 = (Object)adaptor.becomeRoot(
 10765   
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10766   
                 , root_1);
 10767   
 
 10768  8 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10769   
 
 10770   
                 // com\\googlecode\\sparkleg\\Sparql.g:339:43: ^( ARG_LIST argList )
 10771   
                 {
 10772  8 
                 Object root_2 = (Object)adaptor.nil();
 10773  8 
                 root_2 = (Object)adaptor.becomeRoot(
 10774   
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10775   
                 , root_2);
 10776   
 
 10777  8 
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10778   
 
 10779  8 
                 adaptor.addChild(root_1, root_2);
 10780   
                 }
 10781   
 
 10782  8 
                 adaptor.addChild(root_0, root_1);
 10783   
                 }
 10784   
 
 10785   
             }
 10786   
 
 10787   
 
 10788  8 
             retval.tree = root_0;
 10789   
 
 10790   
             }
 10791   
 
 10792  8 
             retval.stop = input.LT(-1);
 10793   
 
 10794   
 
 10795  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10796  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10797   
 
 10798   
         }
 10799  0 
         catch (RecognitionException re) {
 10800  0 
             reportError(re);
 10801  0 
             recover(input,re);
 10802  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10803   
 
 10804   
         }
 10805   
 
 10806  0 
         finally {
 10807   
                 // do for sure before leaving
 10808  8 
         }
 10809  8 
         return retval;
 10810   
     }
 10811   
     // $ANTLR end "functionCall"
 10812   
 
 10813   
 
 10814  56 
     public static class argList_return extends ParserRuleReturnScope {
 10815   
         Object tree;
 10816  56 
         public Object getTree() { return tree; }
 10817   
     };
 10818   
 
 10819   
 
 10820   
     // $ANTLR start "argList"
 10821   
     // com\\googlecode\\sparkleg\\Sparql.g:342:1: argList : ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* );
 10822   
     public final SparqlParser.argList_return argList() throws RecognitionException {
 10823  56 
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 10824  56 
         retval.start = input.LT(1);
 10825   
 
 10826   
 
 10827  56 
         Object root_0 = null;
 10828   
 
 10829  56 
         Token OPEN_BRACE244=null;
 10830  56 
         Token DISTINCT245=null;
 10831  56 
         Token COMMA247=null;
 10832  56 
         Token CLOSE_BRACE249=null;
 10833  56 
         SparqlParser.nil_return nil243 =null;
 10834   
 
 10835  56 
         SparqlParser.expression_return expression246 =null;
 10836   
 
 10837  56 
         SparqlParser.expression_return expression248 =null;
 10838   
 
 10839   
 
 10840  56 
         Object OPEN_BRACE244_tree=null;
 10841  56 
         Object DISTINCT245_tree=null;
 10842  56 
         Object COMMA247_tree=null;
 10843  56 
         Object CLOSE_BRACE249_tree=null;
 10844  56 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10845  56 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 10846  56 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10847  56 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 10848  56 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10849  56 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 10850   
         try {
 10851   
             // com\\googlecode\\sparkleg\\Sparql.g:343:5: ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* )
 10852  56 
             int alt79=2;
 10853  56 
             switch ( input.LA(1) ) {
 10854   
             case OPEN_BRACE:
 10855   
                 {
 10856  56 
                 switch ( input.LA(2) ) {
 10857   
                 case CLOSE_BRACE:
 10858   
                     {
 10859  6 
                     alt79=1;
 10860   
                     }
 10861  6 
                     break;
 10862   
                 case ABS:
 10863   
                 case AVG:
 10864   
                 case BNODE:
 10865   
                 case BOUND:
 10866   
                 case CEIL:
 10867   
                 case COALESCE:
 10868   
                 case CONCAT:
 10869   
                 case CONTAINS:
 10870   
                 case COUNT:
 10871   
                 case DATATYPE:
 10872   
                 case DAY:
 10873   
                 case DECIMAL:
 10874   
                 case DECIMAL_NEGATIVE:
 10875   
                 case DECIMAL_POSITIVE:
 10876   
                 case DISTINCT:
 10877   
                 case DOUBLE:
 10878   
                 case DOUBLE_NEGATIVE:
 10879   
                 case DOUBLE_POSITIVE:
 10880   
                 case ENCODE_FOR_URI:
 10881   
                 case EXISTS:
 10882   
                 case FALSE:
 10883   
                 case FLOOR:
 10884   
                 case GROUP_CONCAT:
 10885   
                 case HOURS:
 10886   
                 case IF:
 10887   
                 case INTEGER:
 10888   
                 case INTEGER_NEGATIVE:
 10889   
                 case INTEGER_POSITIVE:
 10890   
                 case IRI:
 10891   
                 case IRI_REF:
 10892   
                 case ISBLANK:
 10893   
                 case ISIRI:
 10894   
                 case ISLITERAL:
 10895   
                 case ISNUMERIC:
 10896   
                 case ISURI:
 10897   
                 case LANG:
 10898   
                 case LANGMATCHES:
 10899   
                 case LCASE:
 10900   
                 case MAX:
 10901   
                 case MD5:
 10902   
                 case MIN:
 10903   
                 case MINUS:
 10904   
                 case MINUTES:
 10905   
                 case MONTH:
 10906   
                 case NEGATION:
 10907   
                 case NOT:
 10908   
                 case NOW:
 10909   
                 case OPEN_BRACE:
 10910   
                 case PLUS:
 10911   
                 case PNAME_LN:
 10912   
                 case PNAME_NS:
 10913   
                 case RAND:
 10914   
                 case REGEX:
 10915   
                 case REPLACE:
 10916   
                 case ROUND:
 10917   
                 case SAMETERM:
 10918   
                 case SAMPLE:
 10919   
                 case SECONDS:
 10920   
                 case SHA1:
 10921   
                 case SHA224:
 10922   
                 case SHA256:
 10923   
                 case SHA384:
 10924   
                 case SHA512:
 10925   
                 case STR:
 10926   
                 case STRAFTER:
 10927   
                 case STRBEFORE:
 10928   
                 case STRDT:
 10929   
                 case STRENDS:
 10930   
                 case STRING_LITERAL1:
 10931   
                 case STRING_LITERAL2:
 10932   
                 case STRING_LITERAL_LONG1:
 10933   
                 case STRING_LITERAL_LONG2:
 10934   
                 case STRLANG:
 10935   
                 case STRLEN:
 10936   
                 case STRSTARTS:
 10937   
                 case SUBSTR:
 10938   
                 case SUM:
 10939   
                 case TIMEZONE:
 10940   
                 case TRUE:
 10941   
                 case TZ:
 10942   
                 case UCASE:
 10943   
                 case URI:
 10944   
                 case VAR1:
 10945   
                 case VAR2:
 10946   
                 case YEAR:
 10947   
                     {
 10948  50 
                     alt79=2;
 10949   
                     }
 10950  50 
                     break;
 10951   
                 default:
 10952  0 
                     NoViableAltException nvae =
 10953   
                         new NoViableAltException("", 79, 1, input);
 10954   
 
 10955  0 
                     throw nvae;
 10956   
 
 10957   
                 }
 10958   
 
 10959   
                 }
 10960  56 
                 break;
 10961   
             default:
 10962  0 
                 NoViableAltException nvae =
 10963   
                     new NoViableAltException("", 79, 0, input);
 10964   
 
 10965  0 
                 throw nvae;
 10966   
 
 10967   
             }
 10968   
 
 10969  56 
             switch (alt79) {
 10970   
                 case 1 :
 10971   
                     // com\\googlecode\\sparkleg\\Sparql.g:343:7: nil
 10972   
                     {
 10973  6 
                     pushFollow(FOLLOW_nil_in_argList2798);
 10974  6 
                     nil243=nil();
 10975   
 
 10976  6 
                     state._fsp--;
 10977   
 
 10978  6 
                     stream_nil.add(nil243.getTree());
 10979   
 
 10980   
                     // AST REWRITE
 10981   
                     // elements: nil
 10982   
                     // token labels:
 10983   
                     // rule labels: retval
 10984   
                     // token list labels:
 10985   
                     // rule list labels:
 10986   
                     // wildcard labels:
 10987  6 
                     retval.tree = root_0;
 10988  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10989   
 
 10990  6 
                     root_0 = (Object)adaptor.nil();
 10991   
                     // 343:11: -> nil
 10992   
                     {
 10993  6 
                         adaptor.addChild(root_0, stream_nil.nextTree());
 10994   
 
 10995   
                     }
 10996   
 
 10997   
 
 10998  6 
                     retval.tree = root_0;
 10999   
 
 11000   
                     }
 11001  6 
                     break;
 11002   
                 case 2 :
 11003   
                     // com\\googlecode\\sparkleg\\Sparql.g:344:7: OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE
 11004   
                     {
 11005  50 
                     OPEN_BRACE244=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_argList2810);
 11006  50 
                     stream_OPEN_BRACE.add(OPEN_BRACE244);
 11007   
 
 11008   
 
 11009   
                     // com\\googlecode\\sparkleg\\Sparql.g:344:18: ( DISTINCT )?
 11010  50 
                     int alt77=2;
 11011  50 
                     switch ( input.LA(1) ) {
 11012   
                         case DISTINCT:
 11013   
                             {
 11014  0 
                             alt77=1;
 11015   
                             }
 11016   
                             break;
 11017   
                     }
 11018   
 
 11019  50 
                     switch (alt77) {
 11020   
                         case 1 :
 11021   
                             // com\\googlecode\\sparkleg\\Sparql.g:344:18: DISTINCT
 11022   
                             {
 11023  0 
                             DISTINCT245=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2812);
 11024  0 
                             stream_DISTINCT.add(DISTINCT245);
 11025   
 
 11026   
 
 11027   
                             }
 11028   
                             break;
 11029   
 
 11030   
                     }
 11031   
 
 11032   
 
 11033  50 
                     pushFollow(FOLLOW_expression_in_argList2815);
 11034  50 
                     expression246=expression();
 11035   
 
 11036  50 
                     state._fsp--;
 11037   
 
 11038  50 
                     stream_expression.add(expression246.getTree());
 11039   
 
 11040   
                     // com\\googlecode\\sparkleg\\Sparql.g:344:39: ( COMMA expression )*
 11041   
                     loop78:
 11042   
                     do {
 11043  68 
                         int alt78=2;
 11044  68 
                         switch ( input.LA(1) ) {
 11045   
                         case COMMA:
 11046   
                             {
 11047  18 
                             alt78=1;
 11048   
                             }
 11049   
                             break;
 11050   
 
 11051   
                         }
 11052   
 
 11053  68 
                         switch (alt78) {
 11054   
                             case 1 :
 11055   
                                 // com\\googlecode\\sparkleg\\Sparql.g:344:40: COMMA expression
 11056   
                                 {
 11057  18 
                                 COMMA247=(Token)match(input,COMMA,FOLLOW_COMMA_in_argList2818);
 11058  18 
                                 stream_COMMA.add(COMMA247);
 11059   
 
 11060   
 
 11061  18 
                                 pushFollow(FOLLOW_expression_in_argList2820);
 11062  18 
                                 expression248=expression();
 11063   
 
 11064  18 
                                 state._fsp--;
 11065   
 
 11066  18 
                                 stream_expression.add(expression248.getTree());
 11067   
 
 11068   
                                 }
 11069  18 
                                 break;
 11070   
 
 11071   
                             default :
 11072  50 
                                 break loop78;
 11073   
                         }
 11074  18 
                     } while (true);
 11075   
 
 11076   
 
 11077  50 
                     CLOSE_BRACE249=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_argList2824);
 11078  50 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE249);
 11079   
 
 11080   
 
 11081   
                     // AST REWRITE
 11082   
                     // elements: expression, DISTINCT
 11083   
                     // token labels:
 11084   
                     // rule labels: retval
 11085   
                     // token list labels:
 11086   
                     // rule list labels:
 11087   
                     // wildcard labels:
 11088  50 
                     retval.tree = root_0;
 11089  50 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11090   
 
 11091  50 
                     root_0 = (Object)adaptor.nil();
 11092   
                     // 344:71: -> ( DISTINCT )? ( expression )*
 11093   
                     {
 11094   
                         // com\\googlecode\\sparkleg\\Sparql.g:344:74: ( DISTINCT )?
 11095  50 
                         if ( stream_DISTINCT.hasNext() ) {
 11096  0 
                             adaptor.addChild(root_0,
 11097   
                             stream_DISTINCT.nextNode()
 11098   
                             );
 11099   
 
 11100   
                         }
 11101  50 
                         stream_DISTINCT.reset();
 11102   
 
 11103   
                         // com\\googlecode\\sparkleg\\Sparql.g:344:84: ( expression )*
 11104  118 
                         while ( stream_expression.hasNext() ) {
 11105  68 
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11106   
 
 11107   
                         }
 11108  50 
                         stream_expression.reset();
 11109   
 
 11110   
                     }
 11111   
 
 11112   
 
 11113  50 
                     retval.tree = root_0;
 11114   
 
 11115   
                     }
 11116   
                     break;
 11117   
 
 11118   
             }
 11119  56 
             retval.stop = input.LT(-1);
 11120   
 
 11121   
 
 11122  56 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11123  56 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11124   
 
 11125   
         }
 11126  0 
         catch (RecognitionException re) {
 11127  0 
             reportError(re);
 11128  0 
             recover(input,re);
 11129  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11130   
 
 11131   
         }
 11132   
 
 11133  0 
         finally {
 11134   
                 // do for sure before leaving
 11135  56 
         }
 11136  56 
         return retval;
 11137   
     }
 11138   
     // $ANTLR end "argList"
 11139   
 
 11140   
 
 11141  30 
     public static class expressionList_return extends ParserRuleReturnScope {
 11142   
         Object tree;
 11143  30 
         public Object getTree() { return tree; }
 11144   
     };
 11145   
 
 11146   
 
 11147   
     // $ANTLR start "expressionList"
 11148   
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: expressionList : ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11149   
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11150  30 
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11151  30 
         retval.start = input.LT(1);
 11152   
 
 11153   
 
 11154  30 
         Object root_0 = null;
 11155   
 
 11156  30 
         Token OPEN_BRACE251=null;
 11157  30 
         Token COMMA253=null;
 11158  30 
         Token CLOSE_BRACE255=null;
 11159  30 
         SparqlParser.nil_return nil250 =null;
 11160   
 
 11161  30 
         SparqlParser.expression_return expression252 =null;
 11162   
 
 11163  30 
         SparqlParser.expression_return expression254 =null;
 11164   
 
 11165   
 
 11166  30 
         Object OPEN_BRACE251_tree=null;
 11167  30 
         Object COMMA253_tree=null;
 11168  30 
         Object CLOSE_BRACE255_tree=null;
 11169  30 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 11170  30 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 11171  30 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 11172  30 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11173  30 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11174   
         try {
 11175   
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11176   
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11177   
             {
 11178   
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11179  30 
             int alt81=2;
 11180  30 
             switch ( input.LA(1) ) {
 11181   
             case OPEN_BRACE:
 11182   
                 {
 11183  30 
                 switch ( input.LA(2) ) {
 11184   
                 case CLOSE_BRACE:
 11185   
                     {
 11186  2 
                     alt81=1;
 11187   
                     }
 11188  2 
                     break;
 11189   
                 case ABS:
 11190   
                 case AVG:
 11191   
                 case BNODE:
 11192   
                 case BOUND:
 11193   
                 case CEIL:
 11194   
                 case COALESCE:
 11195   
                 case CONCAT:
 11196   
                 case CONTAINS:
 11197   
                 case COUNT:
 11198   
                 case DATATYPE:
 11199   
                 case DAY:
 11200   
                 case DECIMAL:
 11201   
                 case DECIMAL_NEGATIVE:
 11202   
                 case DECIMAL_POSITIVE:
 11203   
                 case DOUBLE:
 11204   
                 case DOUBLE_NEGATIVE:
 11205   
                 case DOUBLE_POSITIVE:
 11206   
                 case ENCODE_FOR_URI:
 11207   
                 case EXISTS:
 11208   
                 case FALSE:
 11209   
                 case FLOOR:
 11210   
                 case GROUP_CONCAT:
 11211   
                 case HOURS:
 11212   
                 case IF:
 11213   
                 case INTEGER:
 11214   
                 case INTEGER_NEGATIVE:
 11215   
                 case INTEGER_POSITIVE:
 11216   
                 case IRI:
 11217   
                 case IRI_REF:
 11218   
                 case ISBLANK:
 11219   
                 case ISIRI:
 11220   
                 case ISLITERAL:
 11221   
                 case ISNUMERIC:
 11222   
                 case ISURI:
 11223   
                 case LANG:
 11224   
                 case LANGMATCHES:
 11225   
                 case LCASE:
 11226   
                 case MAX:
 11227   
                 case MD5:
 11228   
                 case MIN:
 11229   
                 case MINUS:
 11230   
                 case MINUTES:
 11231   
                 case MONTH:
 11232   
                 case NEGATION:
 11233   
                 case NOT:
 11234   
                 case NOW:
 11235   
                 case OPEN_BRACE:
 11236   
                 case PLUS:
 11237   
                 case PNAME_LN:
 11238   
                 case PNAME_NS:
 11239   
                 case RAND:
 11240   
                 case REGEX:
 11241   
                 case REPLACE:
 11242   
                 case ROUND:
 11243   
                 case SAMETERM:
 11244   
                 case SAMPLE:
 11245   
                 case SECONDS:
 11246   
                 case SHA1:
 11247   
                 case SHA224:
 11248   
                 case SHA256:
 11249   
                 case SHA384:
 11250   
                 case SHA512:
 11251   
                 case STR:
 11252   
                 case STRAFTER:
 11253   
                 case STRBEFORE:
 11254   
                 case STRDT:
 11255   
                 case STRENDS:
 11256   
                 case STRING_LITERAL1:
 11257   
                 case STRING_LITERAL2:
 11258   
                 case STRING_LITERAL_LONG1:
 11259   
                 case STRING_LITERAL_LONG2:
 11260   
                 case STRLANG:
 11261   
                 case STRLEN:
 11262   
                 case STRSTARTS:
 11263   
                 case SUBSTR:
 11264   
                 case SUM:
 11265   
                 case TIMEZONE:
 11266   
                 case TRUE:
 11267   
                 case TZ:
 11268   
                 case UCASE:
 11269   
                 case URI:
 11270   
                 case VAR1:
 11271   
                 case VAR2:
 11272   
                 case YEAR:
 11273   
                     {
 11274  28 
                     alt81=2;
 11275   
                     }
 11276  28 
                     break;
 11277   
                 default:
 11278  0 
                     NoViableAltException nvae =
 11279   
                         new NoViableAltException("", 81, 1, input);
 11280   
 
 11281  0 
                     throw nvae;
 11282   
 
 11283   
                 }
 11284   
 
 11285   
                 }
 11286  30 
                 break;
 11287   
             default:
 11288  0 
                 NoViableAltException nvae =
 11289   
                     new NoViableAltException("", 81, 0, input);
 11290   
 
 11291  0 
                 throw nvae;
 11292   
 
 11293   
             }
 11294   
 
 11295  30 
             switch (alt81) {
 11296   
                 case 1 :
 11297   
                     // com\\googlecode\\sparkleg\\Sparql.g:348:8: nil
 11298   
                     {
 11299  2 
                     pushFollow(FOLLOW_nil_in_expressionList2850);
 11300  2 
                     nil250=nil();
 11301   
 
 11302  2 
                     state._fsp--;
 11303   
 
 11304  2 
                     stream_nil.add(nil250.getTree());
 11305   
 
 11306   
                     }
 11307  2 
                     break;
 11308   
                 case 2 :
 11309   
                     // com\\googlecode\\sparkleg\\Sparql.g:348:14: OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE
 11310   
                     {
 11311  28 
                     OPEN_BRACE251=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_expressionList2854);
 11312  28 
                     stream_OPEN_BRACE.add(OPEN_BRACE251);
 11313   
 
 11314   
 
 11315  28 
                     pushFollow(FOLLOW_expression_in_expressionList2856);
 11316  28 
                     expression252=expression();
 11317   
 
 11318  28 
                     state._fsp--;
 11319   
 
 11320  28 
                     stream_expression.add(expression252.getTree());
 11321   
 
 11322   
                     // com\\googlecode\\sparkleg\\Sparql.g:348:36: ( COMMA expression )*
 11323   
                     loop80:
 11324   
                     do {
 11325  62 
                         int alt80=2;
 11326  62 
                         switch ( input.LA(1) ) {
 11327   
                         case COMMA:
 11328   
                             {
 11329  34 
                             alt80=1;
 11330   
                             }
 11331   
                             break;
 11332   
 
 11333   
                         }
 11334   
 
 11335  62 
                         switch (alt80) {
 11336   
                             case 1 :
 11337   
                                 // com\\googlecode\\sparkleg\\Sparql.g:348:37: COMMA expression
 11338   
                                 {
 11339  34 
                                 COMMA253=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList2859);
 11340  34 
                                 stream_COMMA.add(COMMA253);
 11341   
 
 11342   
 
 11343  34 
                                 pushFollow(FOLLOW_expression_in_expressionList2861);
 11344  34 
                                 expression254=expression();
 11345   
 
 11346  34 
                                 state._fsp--;
 11347   
 
 11348  34 
                                 stream_expression.add(expression254.getTree());
 11349   
 
 11350   
                                 }
 11351  34 
                                 break;
 11352   
 
 11353   
                             default :
 11354  28 
                                 break loop80;
 11355   
                         }
 11356  34 
                     } while (true);
 11357   
 
 11358   
 
 11359  28 
                     CLOSE_BRACE255=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_expressionList2865);
 11360  28 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE255);
 11361   
 
 11362   
 
 11363   
                     }
 11364   
                     break;
 11365   
 
 11366   
             }
 11367   
 
 11368   
 
 11369   
             // AST REWRITE
 11370   
             // elements: nil, expression
 11371   
             // token labels:
 11372   
             // rule labels: retval
 11373   
             // token list labels:
 11374   
             // rule list labels:
 11375   
             // wildcard labels:
 11376  30 
             retval.tree = root_0;
 11377  30 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11378   
 
 11379  30 
             root_0 = (Object)adaptor.nil();
 11380   
             // 348:69: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11381   
             {
 11382   
                 // com\\googlecode\\sparkleg\\Sparql.g:348:72: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11383   
                 {
 11384  30 
                 Object root_1 = (Object)adaptor.nil();
 11385  30 
                 root_1 = (Object)adaptor.becomeRoot(
 11386   
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11387   
                 , root_1);
 11388   
 
 11389   
                 // com\\googlecode\\sparkleg\\Sparql.g:348:90: ( nil )*
 11390  32 
                 while ( stream_nil.hasNext() ) {
 11391  2 
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11392   
 
 11393   
                 }
 11394  30 
                 stream_nil.reset();
 11395   
 
 11396   
                 // com\\googlecode\\sparkleg\\Sparql.g:348:95: ( expression )*
 11397  92 
                 while ( stream_expression.hasNext() ) {
 11398  62 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11399   
 
 11400   
                 }
 11401  30 
                 stream_expression.reset();
 11402   
 
 11403  30 
                 adaptor.addChild(root_0, root_1);
 11404   
                 }
 11405   
 
 11406   
             }
 11407   
 
 11408   
 
 11409  30 
             retval.tree = root_0;
 11410   
 
 11411   
             }
 11412   
 
 11413  30 
             retval.stop = input.LT(-1);
 11414   
 
 11415   
 
 11416  30 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11417  30 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11418   
 
 11419   
         }
 11420  0 
         catch (RecognitionException re) {
 11421  0 
             reportError(re);
 11422  0 
             recover(input,re);
 11423  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11424   
 
 11425   
         }
 11426   
 
 11427  0 
         finally {
 11428   
                 // do for sure before leaving
 11429  30 
         }
 11430  30 
         return retval;
 11431   
     }
 11432   
     // $ANTLR end "expressionList"
 11433   
 
 11434   
 
 11435  54 
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11436   
         Object tree;
 11437  54 
         public Object getTree() { return tree; }
 11438   
     };
 11439   
 
 11440   
 
 11441   
     // $ANTLR start "constructTemplate"
 11442   
     // com\\googlecode\\sparkleg\\Sparql.g:351:1: constructTemplate : OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11443   
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11444  54 
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11445  54 
         retval.start = input.LT(1);
 11446   
 
 11447   
 
 11448  54 
         Object root_0 = null;
 11449   
 
 11450  54 
         Token OPEN_CURLY_BRACE256=null;
 11451  54 
         Token CLOSE_CURLY_BRACE258=null;
 11452  54 
         SparqlParser.constructTriples_return constructTriples257 =null;
 11453   
 
 11454   
 
 11455  54 
         Object OPEN_CURLY_BRACE256_tree=null;
 11456  54 
         Object CLOSE_CURLY_BRACE258_tree=null;
 11457  54 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 11458  54 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 11459  54 
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11460   
         try {
 11461   
             // com\\googlecode\\sparkleg\\Sparql.g:352:5: ( OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11462   
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE
 11463   
             {
 11464  54 
             OPEN_CURLY_BRACE256=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2896);
 11465  54 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE256);
 11466   
 
 11467   
 
 11468   
             // com\\googlecode\\sparkleg\\Sparql.g:352:24: ( constructTriples )?
 11469  54 
             int alt82=2;
 11470  54 
             switch ( input.LA(1) ) {
 11471   
                 case BLANK_NODE_LABEL:
 11472   
                 case DECIMAL:
 11473   
                 case DECIMAL_NEGATIVE:
 11474   
                 case DECIMAL_POSITIVE:
 11475   
                 case DOUBLE:
 11476   
                 case DOUBLE_NEGATIVE:
 11477   
                 case DOUBLE_POSITIVE:
 11478   
                 case FALSE:
 11479   
                 case INTEGER:
 11480   
                 case INTEGER_NEGATIVE:
 11481   
                 case INTEGER_POSITIVE:
 11482   
                 case IRI_REF:
 11483   
                 case OPEN_BRACE:
 11484   
                 case OPEN_SQUARE_BRACKET:
 11485   
                 case PNAME_LN:
 11486   
                 case PNAME_NS:
 11487   
                 case STRING_LITERAL1:
 11488   
                 case STRING_LITERAL2:
 11489   
                 case STRING_LITERAL_LONG1:
 11490   
                 case STRING_LITERAL_LONG2:
 11491   
                 case TRUE:
 11492   
                 case VAR1:
 11493   
                 case VAR2:
 11494   
                     {
 11495  52 
                     alt82=1;
 11496   
                     }
 11497   
                     break;
 11498   
             }
 11499   
 
 11500  54 
             switch (alt82) {
 11501   
                 case 1 :
 11502   
                     // com\\googlecode\\sparkleg\\Sparql.g:352:24: constructTriples
 11503   
                     {
 11504  52 
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate2898);
 11505  52 
                     constructTriples257=constructTriples();
 11506   
 
 11507  52 
                     state._fsp--;
 11508   
 
 11509  52 
                     stream_constructTriples.add(constructTriples257.getTree());
 11510   
 
 11511   
                     }
 11512   
                     break;
 11513   
 
 11514   
             }
 11515   
 
 11516   
 
 11517  54 
             CLOSE_CURLY_BRACE258=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2901);
 11518  54 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE258);
 11519   
 
 11520   
 
 11521   
             // AST REWRITE
 11522   
             // elements: constructTriples
 11523   
             // token labels:
 11524   
             // rule labels: retval
 11525   
             // token list labels:
 11526   
             // rule list labels:
 11527   
             // wildcard labels:
 11528  54 
             retval.tree = root_0;
 11529  54 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11530   
 
 11531  54 
             root_0 = (Object)adaptor.nil();
 11532   
             // 352:60: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11533   
             {
 11534   
                 // com\\googlecode\\sparkleg\\Sparql.g:352:63: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11535   
                 {
 11536  54 
                 Object root_1 = (Object)adaptor.nil();
 11537  54 
                 root_1 = (Object)adaptor.becomeRoot(
 11538   
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11539   
                 , root_1);
 11540   
 
 11541   
                 // com\\googlecode\\sparkleg\\Sparql.g:352:83: ( constructTriples )?
 11542  54 
                 if ( stream_constructTriples.hasNext() ) {
 11543  52 
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11544   
 
 11545   
                 }
 11546  54 
                 stream_constructTriples.reset();
 11547   
 
 11548  54 
                 adaptor.addChild(root_0, root_1);
 11549   
                 }
 11550   
 
 11551   
             }
 11552   
 
 11553   
 
 11554  54 
             retval.tree = root_0;
 11555   
 
 11556   
             }
 11557   
 
 11558  54 
             retval.stop = input.LT(-1);
 11559   
 
 11560   
 
 11561  54 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11562  54 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11563   
 
 11564   
         }
 11565  0 
         catch (RecognitionException re) {
 11566  0 
             reportError(re);
 11567  0 
             recover(input,re);
 11568  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11569   
 
 11570   
         }
 11571   
 
 11572  0 
         finally {
 11573   
                 // do for sure before leaving
 11574  54 
         }
 11575  54 
         return retval;
 11576   
     }
 11577   
     // $ANTLR end "constructTemplate"
 11578   
 
 11579   
 
 11580  52 
     public static class constructTriples_return extends ParserRuleReturnScope {
 11581   
         Object tree;
 11582  52 
         public Object getTree() { return tree; }
 11583   
     };
 11584   
 
 11585   
 
 11586   
     // $ANTLR start "constructTriples"
 11587   
     // com\\googlecode\\sparkleg\\Sparql.g:355:1: constructTriples : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ ;
 11588   
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11589  52 
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11590  52 
         retval.start = input.LT(1);
 11591   
 
 11592   
 
 11593  52 
         Object root_0 = null;
 11594   
 
 11595  52 
         Token DOT260=null;
 11596  52 
         Token DOT262=null;
 11597  52 
         SparqlParser.triplesSameSubject_return triplesSameSubject259 =null;
 11598   
 
 11599  52 
         SparqlParser.triplesSameSubject_return triplesSameSubject261 =null;
 11600   
 
 11601   
 
 11602  52 
         Object DOT260_tree=null;
 11603  52 
         Object DOT262_tree=null;
 11604  52 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11605  52 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11606   
         try {
 11607   
             // com\\googlecode\\sparkleg\\Sparql.g:356:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ )
 11608   
             // com\\googlecode\\sparkleg\\Sparql.g:356:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 11609   
             {
 11610  52 
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2927);
 11611  52 
             triplesSameSubject259=triplesSameSubject();
 11612   
 
 11613  52 
             state._fsp--;
 11614   
 
 11615  52 
             stream_triplesSameSubject.add(triplesSameSubject259.getTree());
 11616   
 
 11617   
             // com\\googlecode\\sparkleg\\Sparql.g:356:26: ( DOT triplesSameSubject )*
 11618   
             loop83:
 11619   
             do {
 11620  68 
                 int alt83=2;
 11621  68 
                 switch ( input.LA(1) ) {
 11622   
                 case DOT:
 11623   
                     {
 11624  30 
                     switch ( input.LA(2) ) {
 11625   
                     case BLANK_NODE_LABEL:
 11626   
                     case DECIMAL:
 11627   
                     case DECIMAL_NEGATIVE:
 11628   
                     case DECIMAL_POSITIVE:
 11629   
                     case DOUBLE:
 11630   
                     case DOUBLE_NEGATIVE:
 11631   
                     case DOUBLE_POSITIVE:
 11632   
                     case FALSE:
 11633   
                     case INTEGER:
 11634   
                     case INTEGER_NEGATIVE:
 11635   
                     case INTEGER_POSITIVE:
 11636   
                     case IRI_REF:
 11637   
                     case OPEN_BRACE:
 11638   
                     case OPEN_SQUARE_BRACKET:
 11639   
                     case PNAME_LN:
 11640   
                     case PNAME_NS:
 11641   
                     case STRING_LITERAL1:
 11642   
                     case STRING_LITERAL2:
 11643   
                     case STRING_LITERAL_LONG1:
 11644   
                     case STRING_LITERAL_LONG2:
 11645   
                     case TRUE:
 11646   
                     case VAR1:
 11647   
                     case VAR2:
 11648   
                         {
 11649  16 
                         alt83=1;
 11650   
                         }
 11651   
                         break;
 11652   
 
 11653   
                     }
 11654   
 
 11655   
                     }
 11656   
                     break;
 11657   
 
 11658   
                 }
 11659   
 
 11660  68 
                 switch (alt83) {
 11661   
                     case 1 :
 11662   
                         // com\\googlecode\\sparkleg\\Sparql.g:356:27: DOT triplesSameSubject
 11663   
                         {
 11664  16 
                         DOT260=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2930);
 11665  16 
                         stream_DOT.add(DOT260);
 11666   
 
 11667   
 
 11668  16 
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2932);
 11669  16 
                         triplesSameSubject261=triplesSameSubject();
 11670   
 
 11671  16 
                         state._fsp--;
 11672   
 
 11673  16 
                         stream_triplesSameSubject.add(triplesSameSubject261.getTree());
 11674   
 
 11675   
                         }
 11676  16 
                         break;
 11677   
 
 11678   
                     default :
 11679  52 
                         break loop83;
 11680   
                 }
 11681  16 
             } while (true);
 11682   
 
 11683   
 
 11684   
             // com\\googlecode\\sparkleg\\Sparql.g:356:52: ( DOT )?
 11685  52 
             int alt84=2;
 11686  52 
             switch ( input.LA(1) ) {
 11687   
                 case DOT:
 11688   
                     {
 11689  14 
                     alt84=1;
 11690   
                     }
 11691   
                     break;
 11692   
             }
 11693   
 
 11694  52 
             switch (alt84) {
 11695   
                 case 1 :
 11696   
                     // com\\googlecode\\sparkleg\\Sparql.g:356:52: DOT
 11697   
                     {
 11698  14 
                     DOT262=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2936);
 11699  14 
                     stream_DOT.add(DOT262);
 11700   
 
 11701   
 
 11702   
                     }
 11703   
                     break;
 11704   
 
 11705   
             }
 11706   
 
 11707   
 
 11708   
             // AST REWRITE
 11709   
             // elements: triplesSameSubject
 11710   
             // token labels:
 11711   
             // rule labels: retval
 11712   
             // token list labels:
 11713   
             // rule list labels:
 11714   
             // wildcard labels:
 11715  52 
             retval.tree = root_0;
 11716  52 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11717   
 
 11718  52 
             root_0 = (Object)adaptor.nil();
 11719   
             // 356:57: -> ( triplesSameSubject )+
 11720   
             {
 11721  52 
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11722  0 
                     throw new RewriteEarlyExitException();
 11723   
                 }
 11724  120 
                 while ( stream_triplesSameSubject.hasNext() ) {
 11725  68 
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11726   
 
 11727   
                 }
 11728  52 
                 stream_triplesSameSubject.reset();
 11729   
 
 11730   
             }
 11731   
 
 11732   
 
 11733  52 
             retval.tree = root_0;
 11734   
 
 11735   
             }
 11736   
 
 11737  52 
             retval.stop = input.LT(-1);
 11738   
 
 11739   
 
 11740  52 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11741  52 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11742   
 
 11743   
         }
 11744  0 
         catch (RecognitionException re) {
 11745  0 
             reportError(re);
 11746  0 
             recover(input,re);
 11747  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11748   
 
 11749   
         }
 11750   
 
 11751  0 
         finally {
 11752   
                 // do for sure before leaving
 11753  52 
         }
 11754  52 
         return retval;
 11755   
     }
 11756   
     // $ANTLR end "constructTriples"
 11757   
 
 11758   
 
 11759  194 
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11760   
         Object tree;
 11761  194 
         public Object getTree() { return tree; }
 11762   
     };
 11763   
 
 11764   
 
 11765   
     // $ANTLR start "triplesSameSubject"
 11766   
     // com\\googlecode\\sparkleg\\Sparql.g:359:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11767   
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11768  194 
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11769  194 
         retval.start = input.LT(1);
 11770   
 
 11771   
 
 11772  194 
         Object root_0 = null;
 11773   
 
 11774  194 
         SparqlParser.varOrTerm_return varOrTerm263 =null;
 11775   
 
 11776  194 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty264 =null;
 11777   
 
 11778  194 
         SparqlParser.triplesNode_return triplesNode265 =null;
 11779   
 
 11780  194 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty266 =null;
 11781   
 
 11782   
 
 11783  194 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11784  194 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11785  194 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11786   
         try {
 11787   
             // com\\googlecode\\sparkleg\\Sparql.g:360:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 11788  194 
             int alt87=2;
 11789  194 
             switch ( input.LA(1) ) {
 11790   
             case BLANK_NODE_LABEL:
 11791   
             case DECIMAL:
 11792   
             case DECIMAL_NEGATIVE:
 11793   
             case DECIMAL_POSITIVE:
 11794   
             case DOUBLE:
 11795   
             case DOUBLE_NEGATIVE:
 11796   
             case DOUBLE_POSITIVE:
 11797   
             case FALSE:
 11798   
             case INTEGER:
 11799   
             case INTEGER_NEGATIVE:
 11800   
             case INTEGER_POSITIVE:
 11801   
             case IRI_REF:
 11802   
             case PNAME_LN:
 11803   
             case PNAME_NS:
 11804   
             case STRING_LITERAL1:
 11805   
             case STRING_LITERAL2:
 11806   
             case STRING_LITERAL_LONG1:
 11807   
             case STRING_LITERAL_LONG2:
 11808   
             case TRUE:
 11809   
             case VAR1:
 11810   
             case VAR2:
 11811   
                 {
 11812  182 
                 alt87=1;
 11813   
                 }
 11814  182 
                 break;
 11815   
             case OPEN_SQUARE_BRACKET:
 11816   
                 {
 11817  12 
                 switch ( input.LA(2) ) {
 11818   
                 case CLOSE_SQUARE_BRACKET:
 11819   
                     {
 11820  10 
                     alt87=1;
 11821   
                     }
 11822  10 
                     break;
 11823   
                 case A:
 11824   
                 case INVERSE:
 11825   
                 case IRI_REF:
 11826   
                 case NEGATION:
 11827   
                 case OPEN_BRACE:
 11828   
                 case PNAME_LN:
 11829   
                 case PNAME_NS:
 11830   
                 case VAR1:
 11831   
                 case VAR2:
 11832   
                     {
 11833  2 
                     alt87=2;
 11834   
                     }
 11835  2 
                     break;
 11836   
                 default:
 11837  0 
                     NoViableAltException nvae =
 11838   
                         new NoViableAltException("", 87, 2, input);
 11839   
 
 11840  0 
                     throw nvae;
 11841   
 
 11842   
                 }
 11843   
 
 11844   
                 }
 11845  12 
                 break;
 11846   
             case OPEN_BRACE:
 11847   
                 {
 11848  0 
                 switch ( input.LA(2) ) {
 11849   
                 case CLOSE_BRACE:
 11850   
                     {
 11851  0 
                     alt87=1;
 11852   
                     }
 11853  0 
                     break;
 11854   
                 case BLANK_NODE_LABEL:
 11855   
                 case DECIMAL:
 11856   
                 case DECIMAL_NEGATIVE:
 11857   
                 case DECIMAL_POSITIVE:
 11858   
                 case DOUBLE:
 11859   
                 case DOUBLE_NEGATIVE:
 11860   
                 case DOUBLE_POSITIVE:
 11861   
                 case FALSE:
 11862   
                 case INTEGER:
 11863   
                 case INTEGER_NEGATIVE:
 11864   
                 case INTEGER_POSITIVE:
 11865   
                 case IRI_REF:
 11866   
                 case OPEN_BRACE:
 11867   
                 case OPEN_SQUARE_BRACKET:
 11868   
                 case PNAME_LN:
 11869   
                 case PNAME_NS:
 11870   
                 case STRING_LITERAL1:
 11871   
                 case STRING_LITERAL2:
 11872   
                 case STRING_LITERAL_LONG1:
 11873   
                 case STRING_LITERAL_LONG2:
 11874   
                 case TRUE:
 11875   
                 case VAR1:
 11876   
                 case VAR2:
 11877   
                     {
 11878  0 
                     alt87=2;
 11879   
                     }
 11880  0 
                     break;
 11881   
                 default:
 11882  0 
                     NoViableAltException nvae =
 11883   
                         new NoViableAltException("", 87, 3, input);
 11884   
 
 11885  0 
                     throw nvae;
 11886   
 
 11887   
                 }
 11888   
 
 11889   
                 }
 11890  0 
                 break;
 11891   
             default:
 11892  0 
                 NoViableAltException nvae =
 11893   
                     new NoViableAltException("", 87, 0, input);
 11894   
 
 11895  0 
                 throw nvae;
 11896   
 
 11897   
             }
 11898   
 
 11899  194 
             switch (alt87) {
 11900   
                 case 1 :
 11901   
                     // com\\googlecode\\sparkleg\\Sparql.g:360:7: varOrTerm ( propertyListNotEmpty )?
 11902   
                     {
 11903  192 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject2959);
 11904  192 
                     varOrTerm263=varOrTerm();
 11905   
 
 11906  192 
                     state._fsp--;
 11907   
 
 11908  192 
                     stream_varOrTerm.add(varOrTerm263.getTree());
 11909   
 
 11910   
                     // com\\googlecode\\sparkleg\\Sparql.g:360:17: ( propertyListNotEmpty )?
 11911  192 
                     int alt85=2;
 11912  192 
                     switch ( input.LA(1) ) {
 11913   
                         case A:
 11914   
                         case INVERSE:
 11915   
                         case IRI_REF:
 11916   
                         case NEGATION:
 11917   
                         case OPEN_BRACE:
 11918   
                         case PNAME_LN:
 11919   
                         case PNAME_NS:
 11920   
                         case VAR1:
 11921   
                         case VAR2:
 11922   
                             {
 11923  192 
                             alt85=1;
 11924   
                             }
 11925   
                             break;
 11926   
                     }
 11927   
 
 11928  192 
                     switch (alt85) {
 11929   
                         case 1 :
 11930   
                             // com\\googlecode\\sparkleg\\Sparql.g:360:17: propertyListNotEmpty
 11931   
                             {
 11932  192 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2961);
 11933  192 
                             propertyListNotEmpty264=propertyListNotEmpty();
 11934   
 
 11935  192 
                             state._fsp--;
 11936   
 
 11937  192 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty264.getTree());
 11938   
 
 11939   
                             }
 11940   
                             break;
 11941   
 
 11942   
                     }
 11943   
 
 11944   
 
 11945   
                     // AST REWRITE
 11946   
                     // elements: propertyListNotEmpty, varOrTerm
 11947   
                     // token labels:
 11948   
                     // rule labels: retval
 11949   
                     // token list labels:
 11950   
                     // rule list labels:
 11951   
                     // wildcard labels:
 11952  192 
                     retval.tree = root_0;
 11953  192 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11954   
 
 11955  192 
                     root_0 = (Object)adaptor.nil();
 11956   
                     // 360:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 11957   
                     {
 11958   
                         // com\\googlecode\\sparkleg\\Sparql.g:360:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 11959   
                         {
 11960  192 
                         Object root_1 = (Object)adaptor.nil();
 11961  192 
                         root_1 = (Object)adaptor.becomeRoot(
 11962   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 11963   
                         , root_1);
 11964   
 
 11965   
                         // com\\googlecode\\sparkleg\\Sparql.g:360:65: ^( SUBJECT varOrTerm )
 11966   
                         {
 11967  192 
                         Object root_2 = (Object)adaptor.nil();
 11968  192 
                         root_2 = (Object)adaptor.becomeRoot(
 11969   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 11970   
                         , root_2);
 11971   
 
 11972  192 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 11973   
 
 11974  192 
                         adaptor.addChild(root_1, root_2);
 11975   
                         }
 11976   
 
 11977   
                         // com\\googlecode\\sparkleg\\Sparql.g:360:86: ( propertyListNotEmpty )?
 11978  192 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 11979  192 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 11980   
 
 11981   
                         }
 11982  192 
                         stream_propertyListNotEmpty.reset();
 11983   
 
 11984  192 
                         adaptor.addChild(root_0, root_1);
 11985   
                         }
 11986   
 
 11987   
                     }
 11988   
 
 11989   
 
 11990  192 
                     retval.tree = root_0;
 11991   
 
 11992   
                     }
 11993  192 
                     break;
 11994   
                 case 2 :
 11995   
                     // com\\googlecode\\sparkleg\\Sparql.g:361:7: triplesNode ( propertyListNotEmpty )?
 11996   
                     {
 11997  2 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject2985);
 11998  2 
                     triplesNode265=triplesNode();
 11999   
 
 12000  2 
                     state._fsp--;
 12001   
 
 12002  2 
                     stream_triplesNode.add(triplesNode265.getTree());
 12003   
 
 12004   
                     // com\\googlecode\\sparkleg\\Sparql.g:361:19: ( propertyListNotEmpty )?
 12005  2 
                     int alt86=2;
 12006  2 
                     switch ( input.LA(1) ) {
 12007   
                         case A:
 12008   
                         case INVERSE:
 12009   
                         case IRI_REF:
 12010   
                         case NEGATION:
 12011   
                         case OPEN_BRACE:
 12012   
                         case PNAME_LN:
 12013   
                         case PNAME_NS:
 12014   
                         case VAR1:
 12015   
                         case VAR2:
 12016   
                             {
 12017  0 
                             alt86=1;
 12018   
                             }
 12019   
                             break;
 12020   
                     }
 12021   
 
 12022  2 
                     switch (alt86) {
 12023   
                         case 1 :
 12024   
                             // com\\googlecode\\sparkleg\\Sparql.g:361:19: propertyListNotEmpty
 12025   
                             {
 12026  0 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2987);
 12027  0 
                             propertyListNotEmpty266=propertyListNotEmpty();
 12028   
 
 12029  0 
                             state._fsp--;
 12030   
 
 12031  0 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty266.getTree());
 12032   
 
 12033   
                             }
 12034   
                             break;
 12035   
 
 12036   
                     }
 12037   
 
 12038   
 
 12039   
                     // AST REWRITE
 12040   
                     // elements: propertyListNotEmpty, triplesNode
 12041   
                     // token labels:
 12042   
                     // rule labels: retval
 12043   
                     // token list labels:
 12044   
                     // rule list labels:
 12045   
                     // wildcard labels:
 12046  2 
                     retval.tree = root_0;
 12047  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12048   
 
 12049  2 
                     root_0 = (Object)adaptor.nil();
 12050   
                     // 361:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12051   
                     {
 12052   
                         // com\\googlecode\\sparkleg\\Sparql.g:361:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12053   
                         {
 12054  2 
                         Object root_1 = (Object)adaptor.nil();
 12055  2 
                         root_1 = (Object)adaptor.becomeRoot(
 12056   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12057   
                         , root_1);
 12058   
 
 12059  2 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12060   
 
 12061   
                         // com\\googlecode\\sparkleg\\Sparql.g:361:79: ( propertyListNotEmpty )?
 12062  2 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12063  0 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12064   
 
 12065   
                         }
 12066  2 
                         stream_propertyListNotEmpty.reset();
 12067   
 
 12068  2 
                         adaptor.addChild(root_0, root_1);
 12069   
                         }
 12070   
 
 12071   
                     }
 12072   
 
 12073   
 
 12074  2 
                     retval.tree = root_0;
 12075   
 
 12076   
                     }
 12077   
                     break;
 12078   
 
 12079   
             }
 12080  194 
             retval.stop = input.LT(-1);
 12081   
 
 12082   
 
 12083  194 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12084  194 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12085   
 
 12086   
         }
 12087  0 
         catch (RecognitionException re) {
 12088  0 
             reportError(re);
 12089  0 
             recover(input,re);
 12090  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12091   
 
 12092   
         }
 12093   
 
 12094  0 
         finally {
 12095   
                 // do for sure before leaving
 12096  194 
         }
 12097  194 
         return retval;
 12098   
     }
 12099   
     // $ANTLR end "triplesSameSubject"
 12100   
 
 12101   
 
 12102  230 
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12103   
         Object tree;
 12104  230 
         public Object getTree() { return tree; }
 12105   
     };
 12106   
 
 12107   
 
 12108   
     // $ANTLR start "propertyListNotEmpty"
 12109   
     // com\\googlecode\\sparkleg\\Sparql.g:364:1: propertyListNotEmpty : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12110   
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12111  230 
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12112  230 
         retval.start = input.LT(1);
 12113   
 
 12114   
 
 12115  230 
         Object root_0 = null;
 12116   
 
 12117  230 
         Token SEMICOLON268=null;
 12118  230 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails267 =null;
 12119   
 
 12120  230 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails269 =null;
 12121   
 
 12122   
 
 12123  230 
         Object SEMICOLON268_tree=null;
 12124  230 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12125  230 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12126   
         try {
 12127   
             // com\\googlecode\\sparkleg\\Sparql.g:365:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12128   
             // com\\googlecode\\sparkleg\\Sparql.g:365:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12129   
             {
 12130  230 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3017);
 12131  230 
             propertyListNotEmptyDetails267=propertyListNotEmptyDetails();
 12132   
 
 12133  230 
             state._fsp--;
 12134   
 
 12135  230 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails267.getTree());
 12136   
 
 12137   
             // com\\googlecode\\sparkleg\\Sparql.g:365:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12138   
             loop89:
 12139   
             do {
 12140  260 
                 int alt89=2;
 12141  260 
                 switch ( input.LA(1) ) {
 12142   
                 case SEMICOLON:
 12143   
                     {
 12144  30 
                     alt89=1;
 12145   
                     }
 12146   
                     break;
 12147   
 
 12148   
                 }
 12149   
 
 12150  260 
                 switch (alt89) {
 12151   
                     case 1 :
 12152   
                         // com\\googlecode\\sparkleg\\Sparql.g:365:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12153   
                         {
 12154  30 
                         SEMICOLON268=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmpty3020);
 12155  30 
                         stream_SEMICOLON.add(SEMICOLON268);
 12156   
 
 12157   
 
 12158   
                         // com\\googlecode\\sparkleg\\Sparql.g:365:46: ( propertyListNotEmptyDetails )?
 12159  30 
                         int alt88=2;
 12160  30 
                         switch ( input.LA(1) ) {
 12161   
                             case A:
 12162   
                             case INVERSE:
 12163   
                             case IRI_REF:
 12164   
                             case NEGATION:
 12165   
                             case OPEN_BRACE:
 12166   
                             case PNAME_LN:
 12167   
                             case PNAME_NS:
 12168   
                             case VAR1:
 12169   
                             case VAR2:
 12170   
                                 {
 12171  28 
                                 alt88=1;
 12172   
                                 }
 12173   
                                 break;
 12174   
                         }
 12175   
 
 12176  30 
                         switch (alt88) {
 12177   
                             case 1 :
 12178   
                                 // com\\googlecode\\sparkleg\\Sparql.g:365:46: propertyListNotEmptyDetails
 12179   
                                 {
 12180  28 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3022);
 12181  28 
                                 propertyListNotEmptyDetails269=propertyListNotEmptyDetails();
 12182   
 
 12183  28 
                                 state._fsp--;
 12184   
 
 12185  28 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails269.getTree());
 12186   
 
 12187   
                                 }
 12188   
                                 break;
 12189   
 
 12190   
                         }
 12191   
 
 12192   
 
 12193   
                         }
 12194  30 
                         break;
 12195   
 
 12196   
                     default :
 12197  230 
                         break loop89;
 12198   
                 }
 12199  30 
             } while (true);
 12200   
 
 12201   
 
 12202   
             // AST REWRITE
 12203   
             // elements: propertyListNotEmptyDetails
 12204   
             // token labels:
 12205   
             // rule labels: retval
 12206   
             // token list labels:
 12207   
             // rule list labels:
 12208   
             // wildcard labels:
 12209  230 
             retval.tree = root_0;
 12210  230 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12211   
 
 12212  230 
             root_0 = (Object)adaptor.nil();
 12213   
             // 365:77: -> ( propertyListNotEmptyDetails )+
 12214   
             {
 12215  230 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12216  0 
                     throw new RewriteEarlyExitException();
 12217   
                 }
 12218  488 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12219  258 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12220   
 
 12221   
                 }
 12222  230 
                 stream_propertyListNotEmptyDetails.reset();
 12223   
 
 12224   
             }
 12225   
 
 12226   
 
 12227  230 
             retval.tree = root_0;
 12228   
 
 12229   
             }
 12230   
 
 12231  230 
             retval.stop = input.LT(-1);
 12232   
 
 12233   
 
 12234  230 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12235  230 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12236   
 
 12237   
         }
 12238  0 
         catch (RecognitionException re) {
 12239  0 
             reportError(re);
 12240  0 
             recover(input,re);
 12241  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12242   
 
 12243   
         }
 12244   
 
 12245  0 
         finally {
 12246   
                 // do for sure before leaving
 12247  230 
         }
 12248  230 
         return retval;
 12249   
     }
 12250   
     // $ANTLR end "propertyListNotEmpty"
 12251   
 
 12252   
 
 12253  3394 
     public static class objectList_return extends ParserRuleReturnScope {
 12254   
         Object tree;
 12255  3394 
         public Object getTree() { return tree; }
 12256   
     };
 12257   
 
 12258   
 
 12259   
     // $ANTLR start "objectList"
 12260   
     // com\\googlecode\\sparkleg\\Sparql.g:368:1: objectList : graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12261   
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12262  3394 
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12263  3394 
         retval.start = input.LT(1);
 12264   
 
 12265   
 
 12266  3394 
         Object root_0 = null;
 12267   
 
 12268  3394 
         Token COMMA271=null;
 12269  3394 
         SparqlParser.graphNode_return graphNode270 =null;
 12270   
 
 12271  3394 
         SparqlParser.graphNode_return graphNode272 =null;
 12272   
 
 12273   
 
 12274  3394 
         Object COMMA271_tree=null;
 12275  3394 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 12276  3394 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12277   
         try {
 12278   
             // com\\googlecode\\sparkleg\\Sparql.g:369:5: ( graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12279   
             // com\\googlecode\\sparkleg\\Sparql.g:369:7: graphNode ( COMMA graphNode )*
 12280   
             {
 12281  3394 
             pushFollow(FOLLOW_graphNode_in_objectList3048);
 12282  3394 
             graphNode270=graphNode();
 12283   
 
 12284  3394 
             state._fsp--;
 12285   
 
 12286  3394 
             stream_graphNode.add(graphNode270.getTree());
 12287   
 
 12288   
             // com\\googlecode\\sparkleg\\Sparql.g:369:17: ( COMMA graphNode )*
 12289   
             loop90:
 12290   
             do {
 12291  3408 
                 int alt90=2;
 12292  3408 
                 switch ( input.LA(1) ) {
 12293   
                 case COMMA:
 12294   
                     {
 12295  14 
                     alt90=1;
 12296   
                     }
 12297   
                     break;
 12298   
 
 12299   
                 }
 12300   
 
 12301  3408 
                 switch (alt90) {
 12302   
                     case 1 :
 12303   
                         // com\\googlecode\\sparkleg\\Sparql.g:369:18: COMMA graphNode
 12304   
                         {
 12305  14 
                         COMMA271=(Token)match(input,COMMA,FOLLOW_COMMA_in_objectList3051);
 12306  14 
                         stream_COMMA.add(COMMA271);
 12307   
 
 12308   
 
 12309  14 
                         pushFollow(FOLLOW_graphNode_in_objectList3053);
 12310  14 
                         graphNode272=graphNode();
 12311   
 
 12312  14 
                         state._fsp--;
 12313   
 
 12314  14 
                         stream_graphNode.add(graphNode272.getTree());
 12315   
 
 12316   
                         }
 12317  14 
                         break;
 12318   
 
 12319   
                     default :
 12320  3394 
                         break loop90;
 12321   
                 }
 12322  14 
             } while (true);
 12323   
 
 12324   
 
 12325   
             // AST REWRITE
 12326   
             // elements: graphNode
 12327   
             // token labels:
 12328   
             // rule labels: retval
 12329   
             // token list labels:
 12330   
             // rule list labels:
 12331   
             // wildcard labels:
 12332  3394 
             retval.tree = root_0;
 12333  3394 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12334   
 
 12335  3394 
             root_0 = (Object)adaptor.nil();
 12336   
             // 369:36: -> ( ^( OBJECT graphNode ) )+
 12337   
             {
 12338  3394 
                 if ( !(stream_graphNode.hasNext()) ) {
 12339  0 
                     throw new RewriteEarlyExitException();
 12340   
                 }
 12341  6802 
                 while ( stream_graphNode.hasNext() ) {
 12342   
                     // com\\googlecode\\sparkleg\\Sparql.g:369:39: ^( OBJECT graphNode )
 12343   
                     {
 12344  3408 
                     Object root_1 = (Object)adaptor.nil();
 12345  3408 
                     root_1 = (Object)adaptor.becomeRoot(
 12346   
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12347   
                     , root_1);
 12348   
 
 12349  3408 
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12350   
 
 12351  3408 
                     adaptor.addChild(root_0, root_1);
 12352  3408 
                     }
 12353   
 
 12354   
                 }
 12355  3394 
                 stream_graphNode.reset();
 12356   
 
 12357   
             }
 12358   
 
 12359   
 
 12360  3394 
             retval.tree = root_0;
 12361   
 
 12362   
             }
 12363   
 
 12364  3394 
             retval.stop = input.LT(-1);
 12365   
 
 12366   
 
 12367  3394 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12368  3394 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12369   
 
 12370   
         }
 12371  0 
         catch (RecognitionException re) {
 12372  0 
             reportError(re);
 12373  0 
             recover(input,re);
 12374  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12375   
 
 12376   
         }
 12377   
 
 12378  0 
         finally {
 12379   
                 // do for sure before leaving
 12380  3394 
         }
 12381  3394 
         return retval;
 12382   
     }
 12383   
     // $ANTLR end "objectList"
 12384   
 
 12385   
 
 12386  0 
     public static class verb_return extends ParserRuleReturnScope {
 12387   
         Object tree;
 12388  0 
         public Object getTree() { return tree; }
 12389   
     };
 12390   
 
 12391   
 
 12392   
     // $ANTLR start "verb"
 12393   
     // com\\googlecode\\sparkleg\\Sparql.g:372:1: verb : ( varOrIRIref | A );
 12394   
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12395  0 
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12396  0 
         retval.start = input.LT(1);
 12397   
 
 12398   
 
 12399  0 
         Object root_0 = null;
 12400   
 
 12401  0 
         Token A274=null;
 12402  0 
         SparqlParser.varOrIRIref_return varOrIRIref273 =null;
 12403   
 
 12404   
 
 12405  0 
         Object A274_tree=null;
 12406   
 
 12407   
         try {
 12408   
             // com\\googlecode\\sparkleg\\Sparql.g:373:5: ( varOrIRIref | A )
 12409  0 
             int alt91=2;
 12410  0 
             switch ( input.LA(1) ) {
 12411   
             case IRI_REF:
 12412   
             case PNAME_LN:
 12413   
             case PNAME_NS:
 12414   
             case VAR1:
 12415   
             case VAR2:
 12416   
                 {
 12417  0 
                 alt91=1;
 12418   
                 }
 12419  0 
                 break;
 12420   
             case A:
 12421   
                 {
 12422  0 
                 alt91=2;
 12423   
                 }
 12424  0 
                 break;
 12425   
             default:
 12426  0 
                 NoViableAltException nvae =
 12427   
                     new NoViableAltException("", 91, 0, input);
 12428   
 
 12429  0 
                 throw nvae;
 12430   
 
 12431   
             }
 12432   
 
 12433  0 
             switch (alt91) {
 12434   
                 case 1 :
 12435   
                     // com\\googlecode\\sparkleg\\Sparql.g:373:7: varOrIRIref
 12436   
                     {
 12437  0 
                     root_0 = (Object)adaptor.nil();
 12438   
 
 12439   
 
 12440  0 
                     pushFollow(FOLLOW_varOrIRIref_in_verb3081);
 12441  0 
                     varOrIRIref273=varOrIRIref();
 12442   
 
 12443  0 
                     state._fsp--;
 12444   
 
 12445  0 
                     adaptor.addChild(root_0, varOrIRIref273.getTree());
 12446   
 
 12447   
                     }
 12448  0 
                     break;
 12449   
                 case 2 :
 12450   
                     // com\\googlecode\\sparkleg\\Sparql.g:374:7: A
 12451   
                     {
 12452  0 
                     root_0 = (Object)adaptor.nil();
 12453   
 
 12454   
 
 12455  0 
                     A274=(Token)match(input,A,FOLLOW_A_in_verb3089);
 12456  0 
                     A274_tree =
 12457   
                     (Object)adaptor.create(A274)
 12458   
                     ;
 12459  0 
                     adaptor.addChild(root_0, A274_tree);
 12460   
 
 12461   
 
 12462   
                     }
 12463   
                     break;
 12464   
 
 12465   
             }
 12466  0 
             retval.stop = input.LT(-1);
 12467   
 
 12468   
 
 12469  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12470  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12471   
 
 12472   
         }
 12473  0 
         catch (RecognitionException re) {
 12474  0 
             reportError(re);
 12475  0 
             recover(input,re);
 12476  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12477   
 
 12478   
         }
 12479   
 
 12480  0 
         finally {
 12481   
                 // do for sure before leaving
 12482  0 
         }
 12483  0 
         return retval;
 12484   
     }
 12485   
     // $ANTLR end "verb"
 12486   
 
 12487   
 
 12488  2964 
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12489   
         Object tree;
 12490  2964 
         public Object getTree() { return tree; }
 12491   
     };
 12492   
 
 12493   
 
 12494   
     // $ANTLR start "triplesSameSubjectPath"
 12495   
     // com\\googlecode\\sparkleg\\Sparql.g:377:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12496   
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12497  2964 
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12498  2964 
         retval.start = input.LT(1);
 12499   
 
 12500   
 
 12501  2964 
         Object root_0 = null;
 12502   
 
 12503  2964 
         SparqlParser.varOrTerm_return varOrTerm275 =null;
 12504   
 
 12505  2964 
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath276 =null;
 12506   
 
 12507  2964 
         SparqlParser.triplesNode_return triplesNode277 =null;
 12508   
 
 12509  2964 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty278 =null;
 12510   
 
 12511   
 
 12512  2964 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12513  2964 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12514  2964 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12515  2964 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12516   
         try {
 12517   
             // com\\googlecode\\sparkleg\\Sparql.g:378:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12518  2964 
             int alt93=2;
 12519  2964 
             switch ( input.LA(1) ) {
 12520   
             case BLANK_NODE_LABEL:
 12521   
             case DECIMAL:
 12522   
             case DECIMAL_NEGATIVE:
 12523   
             case DECIMAL_POSITIVE:
 12524   
             case DOUBLE:
 12525   
             case DOUBLE_NEGATIVE:
 12526   
             case DOUBLE_POSITIVE:
 12527   
             case FALSE:
 12528   
             case INTEGER:
 12529   
             case INTEGER_NEGATIVE:
 12530   
             case INTEGER_POSITIVE:
 12531   
             case IRI_REF:
 12532   
             case PNAME_LN:
 12533   
             case PNAME_NS:
 12534   
             case STRING_LITERAL1:
 12535   
             case STRING_LITERAL2:
 12536   
             case STRING_LITERAL_LONG1:
 12537   
             case STRING_LITERAL_LONG2:
 12538   
             case TRUE:
 12539   
             case VAR1:
 12540   
             case VAR2:
 12541   
                 {
 12542  2872 
                 alt93=1;
 12543   
                 }
 12544  2872 
                 break;
 12545   
             case OPEN_SQUARE_BRACKET:
 12546   
                 {
 12547  66 
                 switch ( input.LA(2) ) {
 12548   
                 case CLOSE_SQUARE_BRACKET:
 12549   
                     {
 12550  54 
                     alt93=1;
 12551   
                     }
 12552  54 
                     break;
 12553   
                 case A:
 12554   
                 case INVERSE:
 12555   
                 case IRI_REF:
 12556   
                 case NEGATION:
 12557   
                 case OPEN_BRACE:
 12558   
                 case PNAME_LN:
 12559   
                 case PNAME_NS:
 12560   
                 case VAR1:
 12561   
                 case VAR2:
 12562   
                     {
 12563  8 
                     alt93=2;
 12564   
                     }
 12565  8 
                     break;
 12566   
                 default:
 12567  4 
                     NoViableAltException nvae =
 12568   
                         new NoViableAltException("", 93, 2, input);
 12569   
 
 12570  4 
                     throw nvae;
 12571   
 
 12572   
                 }
 12573   
 
 12574   
                 }
 12575  62 
                 break;
 12576   
             case OPEN_BRACE:
 12577   
                 {
 12578  26 
                 switch ( input.LA(2) ) {
 12579   
                 case CLOSE_BRACE:
 12580   
                     {
 12581  10 
                     alt93=1;
 12582   
                     }
 12583  10 
                     break;
 12584   
                 case BLANK_NODE_LABEL:
 12585   
                 case DECIMAL:
 12586   
                 case DECIMAL_NEGATIVE:
 12587   
                 case DECIMAL_POSITIVE:
 12588   
                 case DOUBLE:
 12589   
                 case DOUBLE_NEGATIVE:
 12590   
                 case DOUBLE_POSITIVE:
 12591   
                 case FALSE:
 12592   
                 case INTEGER:
 12593   
                 case INTEGER_NEGATIVE:
 12594   
                 case INTEGER_POSITIVE:
 12595   
                 case IRI_REF:
 12596   
                 case OPEN_BRACE:
 12597   
                 case OPEN_SQUARE_BRACKET:
 12598   
                 case PNAME_LN:
 12599   
                 case PNAME_NS:
 12600   
                 case STRING_LITERAL1:
 12601   
                 case STRING_LITERAL2:
 12602   
                 case STRING_LITERAL_LONG1:
 12603   
                 case STRING_LITERAL_LONG2:
 12604   
                 case TRUE:
 12605   
                 case VAR1:
 12606   
                 case VAR2:
 12607   
                     {
 12608  16 
                     alt93=2;
 12609   
                     }
 12610  16 
                     break;
 12611   
                 default:
 12612  0 
                     NoViableAltException nvae =
 12613   
                         new NoViableAltException("", 93, 3, input);
 12614   
 
 12615  0 
                     throw nvae;
 12616   
 
 12617   
                 }
 12618   
 
 12619   
                 }
 12620  26 
                 break;
 12621   
             default:
 12622  0 
                 NoViableAltException nvae =
 12623   
                     new NoViableAltException("", 93, 0, input);
 12624   
 
 12625  0 
                 throw nvae;
 12626   
 
 12627   
             }
 12628   
 
 12629  2960 
             switch (alt93) {
 12630   
                 case 1 :
 12631   
                     // com\\googlecode\\sparkleg\\Sparql.g:378:7: varOrTerm propertyListNotEmptyPath
 12632   
                     {
 12633  2936 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3106);
 12634  2936 
                     varOrTerm275=varOrTerm();
 12635   
 
 12636  2936 
                     state._fsp--;
 12637   
 
 12638  2936 
                     stream_varOrTerm.add(varOrTerm275.getTree());
 12639   
 
 12640  2936 
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3108);
 12641  2936 
                     propertyListNotEmptyPath276=propertyListNotEmptyPath();
 12642   
 
 12643  2936 
                     state._fsp--;
 12644   
 
 12645  2936 
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath276.getTree());
 12646   
 
 12647   
                     // AST REWRITE
 12648   
                     // elements: varOrTerm, propertyListNotEmptyPath
 12649   
                     // token labels:
 12650   
                     // rule labels: retval
 12651   
                     // token list labels:
 12652   
                     // rule list labels:
 12653   
                     // wildcard labels:
 12654  2936 
                     retval.tree = root_0;
 12655  2936 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12656   
 
 12657  2936 
                     root_0 = (Object)adaptor.nil();
 12658   
                     // 378:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12659   
                     {
 12660   
                         // com\\googlecode\\sparkleg\\Sparql.g:378:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12661   
                         {
 12662  2936 
                         Object root_1 = (Object)adaptor.nil();
 12663  2936 
                         root_1 = (Object)adaptor.becomeRoot(
 12664   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12665   
                         , root_1);
 12666   
 
 12667   
                         // com\\googlecode\\sparkleg\\Sparql.g:378:68: ^( SUBJECT varOrTerm )
 12668   
                         {
 12669  2936 
                         Object root_2 = (Object)adaptor.nil();
 12670  2936 
                         root_2 = (Object)adaptor.becomeRoot(
 12671   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12672   
                         , root_2);
 12673   
 
 12674  2936 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12675   
 
 12676  2936 
                         adaptor.addChild(root_1, root_2);
 12677   
                         }
 12678   
 
 12679  2936 
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12680   
 
 12681  2936 
                         adaptor.addChild(root_0, root_1);
 12682   
                         }
 12683   
 
 12684   
                     }
 12685   
 
 12686   
 
 12687  2936 
                     retval.tree = root_0;
 12688   
 
 12689   
                     }
 12690  2936 
                     break;
 12691   
                 case 2 :
 12692   
                     // com\\googlecode\\sparkleg\\Sparql.g:379:7: triplesNode ( propertyListNotEmpty )?
 12693   
                     {
 12694  24 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3130);
 12695  24 
                     triplesNode277=triplesNode();
 12696   
 
 12697  24 
                     state._fsp--;
 12698   
 
 12699  24 
                     stream_triplesNode.add(triplesNode277.getTree());
 12700   
 
 12701   
                     // com\\googlecode\\sparkleg\\Sparql.g:379:19: ( propertyListNotEmpty )?
 12702  24 
                     int alt92=2;
 12703  24 
                     switch ( input.LA(1) ) {
 12704   
                         case A:
 12705   
                         case INVERSE:
 12706   
                         case IRI_REF:
 12707   
                         case NEGATION:
 12708   
                         case OPEN_BRACE:
 12709   
                         case PNAME_LN:
 12710   
                         case PNAME_NS:
 12711   
                         case VAR1:
 12712   
                         case VAR2:
 12713   
                             {
 12714  8 
                             alt92=1;
 12715   
                             }
 12716   
                             break;
 12717   
                     }
 12718   
 
 12719  24 
                     switch (alt92) {
 12720   
                         case 1 :
 12721   
                             // com\\googlecode\\sparkleg\\Sparql.g:379:19: propertyListNotEmpty
 12722   
                             {
 12723  8 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3132);
 12724  8 
                             propertyListNotEmpty278=propertyListNotEmpty();
 12725   
 
 12726  8 
                             state._fsp--;
 12727   
 
 12728  8 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty278.getTree());
 12729   
 
 12730   
                             }
 12731   
                             break;
 12732   
 
 12733   
                     }
 12734   
 
 12735   
 
 12736   
                     // AST REWRITE
 12737   
                     // elements: triplesNode, propertyListNotEmpty
 12738   
                     // token labels:
 12739   
                     // rule labels: retval
 12740   
                     // token list labels:
 12741   
                     // rule list labels:
 12742   
                     // wildcard labels:
 12743  24 
                     retval.tree = root_0;
 12744  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12745   
 
 12746  24 
                     root_0 = (Object)adaptor.nil();
 12747   
                     // 379:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12748   
                     {
 12749   
                         // com\\googlecode\\sparkleg\\Sparql.g:379:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12750   
                         {
 12751  24 
                         Object root_1 = (Object)adaptor.nil();
 12752  24 
                         root_1 = (Object)adaptor.becomeRoot(
 12753   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12754   
                         , root_1);
 12755   
 
 12756  24 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12757   
 
 12758   
                         // com\\googlecode\\sparkleg\\Sparql.g:379:80: ( propertyListNotEmpty )?
 12759  24 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12760  8 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12761   
 
 12762   
                         }
 12763  24 
                         stream_propertyListNotEmpty.reset();
 12764   
 
 12765  24 
                         adaptor.addChild(root_0, root_1);
 12766   
                         }
 12767   
 
 12768   
                     }
 12769   
 
 12770   
 
 12771  24 
                     retval.tree = root_0;
 12772   
 
 12773   
                     }
 12774   
                     break;
 12775   
 
 12776   
             }
 12777  2960 
             retval.stop = input.LT(-1);
 12778   
 
 12779   
 
 12780  2960 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12781  2960 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12782   
 
 12783   
         }
 12784  4 
         catch (RecognitionException re) {
 12785  4 
             reportError(re);
 12786  4 
             recover(input,re);
 12787  4 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12788   
 
 12789   
         }
 12790   
 
 12791  0 
         finally {
 12792   
                 // do for sure before leaving
 12793  2964 
         }
 12794  2964 
         return retval;
 12795   
     }
 12796   
     // $ANTLR end "triplesSameSubjectPath"
 12797   
 
 12798   
 
 12799  2936 
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 12800   
         Object tree;
 12801  2936 
         public Object getTree() { return tree; }
 12802   
     };
 12803   
 
 12804   
 
 12805   
     // $ANTLR start "propertyListNotEmptyPath"
 12806   
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12807   
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 12808  2936 
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 12809  2936 
         retval.start = input.LT(1);
 12810   
 
 12811   
 
 12812  2936 
         Object root_0 = null;
 12813   
 
 12814  2936 
         Token SEMICOLON280=null;
 12815  2936 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails279 =null;
 12816   
 
 12817  2936 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails281 =null;
 12818   
 
 12819   
 
 12820  2936 
         Object SEMICOLON280_tree=null;
 12821  2936 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12822  2936 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12823   
         try {
 12824   
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12825   
             // com\\googlecode\\sparkleg\\Sparql.g:383:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12826   
             {
 12827  2936 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3164);
 12828  2936 
             propertyListNotEmptyDetails279=propertyListNotEmptyDetails();
 12829   
 
 12830  2936 
             state._fsp--;
 12831   
 
 12832  2936 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails279.getTree());
 12833   
 
 12834   
             // com\\googlecode\\sparkleg\\Sparql.g:383:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12835   
             loop95:
 12836   
             do {
 12837  3148 
                 int alt95=2;
 12838  3148 
                 switch ( input.LA(1) ) {
 12839   
                 case SEMICOLON:
 12840   
                     {
 12841  212 
                     alt95=1;
 12842   
                     }
 12843   
                     break;
 12844   
 
 12845   
                 }
 12846   
 
 12847  3148 
                 switch (alt95) {
 12848   
                     case 1 :
 12849   
                         // com\\googlecode\\sparkleg\\Sparql.g:383:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12850   
                         {
 12851  212 
                         SEMICOLON280=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3167);
 12852  212 
                         stream_SEMICOLON.add(SEMICOLON280);
 12853   
 
 12854   
 
 12855   
                         // com\\googlecode\\sparkleg\\Sparql.g:383:46: ( propertyListNotEmptyDetails )?
 12856  212 
                         int alt94=2;
 12857  212 
                         switch ( input.LA(1) ) {
 12858   
                             case A:
 12859   
                             case INVERSE:
 12860   
                             case IRI_REF:
 12861   
                             case NEGATION:
 12862   
                             case OPEN_BRACE:
 12863   
                             case PNAME_LN:
 12864   
                             case PNAME_NS:
 12865   
                             case VAR1:
 12866   
                             case VAR2:
 12867   
                                 {
 12868  200 
                                 alt94=1;
 12869   
                                 }
 12870   
                                 break;
 12871   
                         }
 12872   
 
 12873  212 
                         switch (alt94) {
 12874   
                             case 1 :
 12875   
                                 // com\\googlecode\\sparkleg\\Sparql.g:383:46: propertyListNotEmptyDetails
 12876   
                                 {
 12877  200 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3169);
 12878  200 
                                 propertyListNotEmptyDetails281=propertyListNotEmptyDetails();
 12879   
 
 12880  200 
                                 state._fsp--;
 12881   
 
 12882  200 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails281.getTree());
 12883   
 
 12884   
                                 }
 12885   
                                 break;
 12886   
 
 12887   
                         }
 12888   
 
 12889   
 
 12890   
                         }
 12891  212 
                         break;
 12892   
 
 12893   
                     default :
 12894  2936 
                         break loop95;
 12895   
                 }
 12896  212 
             } while (true);
 12897   
 
 12898   
 
 12899   
             // AST REWRITE
 12900   
             // elements: propertyListNotEmptyDetails
 12901   
             // token labels:
 12902   
             // rule labels: retval
 12903   
             // token list labels:
 12904   
             // rule list labels:
 12905   
             // wildcard labels:
 12906  2936 
             retval.tree = root_0;
 12907  2936 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12908   
 
 12909  2936 
             root_0 = (Object)adaptor.nil();
 12910   
             // 383:77: -> ( propertyListNotEmptyDetails )+
 12911   
             {
 12912  2936 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12913  0 
                     throw new RewriteEarlyExitException();
 12914   
                 }
 12915  6072 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12916  3136 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12917   
 
 12918   
                 }
 12919  2936 
                 stream_propertyListNotEmptyDetails.reset();
 12920   
 
 12921   
             }
 12922   
 
 12923   
 
 12924  2936 
             retval.tree = root_0;
 12925   
 
 12926   
             }
 12927   
 
 12928  2936 
             retval.stop = input.LT(-1);
 12929   
 
 12930   
 
 12931  2936 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12932  2936 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12933   
 
 12934   
         }
 12935  0 
         catch (RecognitionException re) {
 12936  0 
             reportError(re);
 12937  0 
             recover(input,re);
 12938  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12939   
 
 12940   
         }
 12941   
 
 12942  0 
         finally {
 12943   
                 // do for sure before leaving
 12944  2936 
         }
 12945  2936 
         return retval;
 12946   
     }
 12947   
     // $ANTLR end "propertyListNotEmptyPath"
 12948   
 
 12949   
 
 12950  3394 
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 12951   
         Object tree;
 12952  3394 
         public Object getTree() { return tree; }
 12953   
     };
 12954   
 
 12955   
 
 12956   
     // $ANTLR start "propertyListNotEmptyDetails"
 12957   
     // com\\googlecode\\sparkleg\\Sparql.g:386:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 12958   
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 12959  3394 
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 12960  3394 
         retval.start = input.LT(1);
 12961   
 
 12962   
 
 12963  3394 
         Object root_0 = null;
 12964   
 
 12965  3394 
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath282 =null;
 12966   
 
 12967  3394 
         SparqlParser.objectList_return objectList283 =null;
 12968   
 
 12969   
 
 12970  3394 
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 12971  3394 
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 12972   
         try {
 12973   
             // com\\googlecode\\sparkleg\\Sparql.g:387:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 12974   
             // com\\googlecode\\sparkleg\\Sparql.g:387:7: verbSimpleOrPath objectList
 12975   
             {
 12976  3394 
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3196);
 12977  3394 
             verbSimpleOrPath282=verbSimpleOrPath();
 12978   
 
 12979  3394 
             state._fsp--;
 12980   
 
 12981  3394 
             stream_verbSimpleOrPath.add(verbSimpleOrPath282.getTree());
 12982   
 
 12983  3394 
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3198);
 12984  3394 
             objectList283=objectList();
 12985   
 
 12986  3394 
             state._fsp--;
 12987   
 
 12988  3394 
             stream_objectList.add(objectList283.getTree());
 12989   
 
 12990   
             // AST REWRITE
 12991   
             // elements: verbSimpleOrPath, objectList
 12992   
             // token labels:
 12993   
             // rule labels: retval
 12994   
             // token list labels:
 12995   
             // rule list labels:
 12996   
             // wildcard labels:
 12997  3394 
             retval.tree = root_0;
 12998  3394 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12999   
 
 13000  3394 
             root_0 = (Object)adaptor.nil();
 13001   
             // 387:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13002   
             {
 13003   
                 // com\\googlecode\\sparkleg\\Sparql.g:387:38: ^( PREDICATE verbSimpleOrPath objectList )
 13004   
                 {
 13005  3394 
                 Object root_1 = (Object)adaptor.nil();
 13006  3394 
                 root_1 = (Object)adaptor.becomeRoot(
 13007   
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13008   
                 , root_1);
 13009   
 
 13010  3394 
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13011   
 
 13012  3394 
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13013   
 
 13014  3394 
                 adaptor.addChild(root_0, root_1);
 13015   
                 }
 13016   
 
 13017   
             }
 13018   
 
 13019   
 
 13020  3394 
             retval.tree = root_0;
 13021   
 
 13022   
             }
 13023   
 
 13024  3394 
             retval.stop = input.LT(-1);
 13025   
 
 13026   
 
 13027  3394 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13028  3394 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13029   
 
 13030   
         }
 13031  0 
         catch (RecognitionException re) {
 13032  0 
             reportError(re);
 13033  0 
             recover(input,re);
 13034  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13035   
 
 13036   
         }
 13037   
 
 13038  0 
         finally {
 13039   
                 // do for sure before leaving
 13040  3394 
         }
 13041  3394 
         return retval;
 13042   
     }
 13043   
     // $ANTLR end "propertyListNotEmptyDetails"
 13044   
 
 13045   
 
 13046  3394 
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13047   
         Object tree;
 13048  3394 
         public Object getTree() { return tree; }
 13049   
     };
 13050   
 
 13051   
 
 13052   
     // $ANTLR start "verbSimpleOrPath"
 13053   
     // com\\googlecode\\sparkleg\\Sparql.g:390:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13054   
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13055  3394 
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13056  3394 
         retval.start = input.LT(1);
 13057   
 
 13058   
 
 13059  3394 
         Object root_0 = null;
 13060   
 
 13061  3394 
         SparqlParser.verbPath_return verbPath284 =null;
 13062   
 
 13063  3394 
         SparqlParser.verbSimple_return verbSimple285 =null;
 13064   
 
 13065   
 
 13066   
 
 13067   
         try {
 13068   
             // com\\googlecode\\sparkleg\\Sparql.g:391:5: ( verbPath | verbSimple )
 13069  3394 
             int alt96=2;
 13070  3394 
             switch ( input.LA(1) ) {
 13071   
             case A:
 13072   
             case INVERSE:
 13073   
             case IRI_REF:
 13074   
             case NEGATION:
 13075   
             case OPEN_BRACE:
 13076   
             case PNAME_LN:
 13077   
             case PNAME_NS:
 13078   
                 {
 13079  2672 
                 alt96=1;
 13080   
                 }
 13081  2672 
                 break;
 13082   
             case VAR1:
 13083   
             case VAR2:
 13084   
                 {
 13085  702 
                 alt96=2;
 13086   
                 }
 13087  702 
                 break;
 13088   
             default:
 13089  20 
                 NoViableAltException nvae =
 13090   
                     new NoViableAltException("", 96, 0, input);
 13091   
 
 13092  20 
                 throw nvae;
 13093   
 
 13094   
             }
 13095   
 
 13096  3374 
             switch (alt96) {
 13097   
                 case 1 :
 13098   
                     // com\\googlecode\\sparkleg\\Sparql.g:391:7: verbPath
 13099   
                     {
 13100  2672 
                     root_0 = (Object)adaptor.nil();
 13101   
 
 13102   
 
 13103  2672 
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3228);
 13104  2672 
                     verbPath284=verbPath();
 13105   
 
 13106  2672 
                     state._fsp--;
 13107   
 
 13108  2672 
                     adaptor.addChild(root_0, verbPath284.getTree());
 13109   
 
 13110   
                     }
 13111  2672 
                     break;
 13112   
                 case 2 :
 13113   
                     // com\\googlecode\\sparkleg\\Sparql.g:392:7: verbSimple
 13114   
                     {
 13115  702 
                     root_0 = (Object)adaptor.nil();
 13116   
 
 13117   
 
 13118  702 
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3236);
 13119  702 
                     verbSimple285=verbSimple();
 13120   
 
 13121  702 
                     state._fsp--;
 13122   
 
 13123  702 
                     adaptor.addChild(root_0, verbSimple285.getTree());
 13124   
 
 13125   
                     }
 13126   
                     break;
 13127   
 
 13128   
             }
 13129  3374 
             retval.stop = input.LT(-1);
 13130   
 
 13131   
 
 13132  3374 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13133  3374 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13134   
 
 13135   
         }
 13136  20 
         catch (RecognitionException re) {
 13137  20 
             reportError(re);
 13138  20 
             recover(input,re);
 13139  20 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13140   
 
 13141   
         }
 13142   
 
 13143  0 
         finally {
 13144   
                 // do for sure before leaving
 13145  3394 
         }
 13146  3394 
         return retval;
 13147   
     }
 13148   
     // $ANTLR end "verbSimpleOrPath"
 13149   
 
 13150   
 
 13151  2672 
     public static class verbPath_return extends ParserRuleReturnScope {
 13152   
         Object tree;
 13153  2672 
         public Object getTree() { return tree; }
 13154   
     };
 13155   
 
 13156   
 
 13157   
     // $ANTLR start "verbPath"
 13158   
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: verbPath : path ;
 13159   
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13160  2672 
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13161  2672 
         retval.start = input.LT(1);
 13162   
 
 13163   
 
 13164  2672 
         Object root_0 = null;
 13165   
 
 13166  2672 
         SparqlParser.path_return path286 =null;
 13167   
 
 13168   
 
 13169   
 
 13170   
         try {
 13171   
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( path )
 13172   
             // com\\googlecode\\sparkleg\\Sparql.g:396:7: path
 13173   
             {
 13174  2672 
             root_0 = (Object)adaptor.nil();
 13175   
 
 13176   
 
 13177  2672 
             pushFollow(FOLLOW_path_in_verbPath3255);
 13178  2672 
             path286=path();
 13179   
 
 13180  2672 
             state._fsp--;
 13181   
 
 13182  2672 
             adaptor.addChild(root_0, path286.getTree());
 13183   
 
 13184   
             }
 13185   
 
 13186  2672 
             retval.stop = input.LT(-1);
 13187   
 
 13188   
 
 13189  2672 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13190  2672 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13191   
 
 13192   
         }
 13193  0 
         catch (RecognitionException re) {
 13194  0 
             reportError(re);
 13195  0 
             recover(input,re);
 13196  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13197   
 
 13198   
         }
 13199   
 
 13200  0 
         finally {
 13201   
                 // do for sure before leaving
 13202  2672 
         }
 13203  2672 
         return retval;
 13204   
     }
 13205   
     // $ANTLR end "verbPath"
 13206   
 
 13207   
 
 13208  702 
     public static class verbSimple_return extends ParserRuleReturnScope {
 13209   
         Object tree;
 13210  702 
         public Object getTree() { return tree; }
 13211   
     };
 13212   
 
 13213   
 
 13214   
     // $ANTLR start "verbSimple"
 13215   
     // com\\googlecode\\sparkleg\\Sparql.g:399:1: verbSimple : var ;
 13216   
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13217  702 
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13218  702 
         retval.start = input.LT(1);
 13219   
 
 13220   
 
 13221  702 
         Object root_0 = null;
 13222   
 
 13223  702 
         SparqlParser.var_return var287 =null;
 13224   
 
 13225   
 
 13226   
 
 13227   
         try {
 13228   
             // com\\googlecode\\sparkleg\\Sparql.g:400:5: ( var )
 13229   
             // com\\googlecode\\sparkleg\\Sparql.g:400:7: var
 13230   
             {
 13231  702 
             root_0 = (Object)adaptor.nil();
 13232   
 
 13233   
 
 13234  702 
             pushFollow(FOLLOW_var_in_verbSimple3276);
 13235  702 
             var287=var();
 13236   
 
 13237  702 
             state._fsp--;
 13238   
 
 13239  702 
             adaptor.addChild(root_0, var287.getTree());
 13240   
 
 13241   
             }
 13242   
 
 13243  702 
             retval.stop = input.LT(-1);
 13244   
 
 13245   
 
 13246  702 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13247  702 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13248   
 
 13249   
         }
 13250  0 
         catch (RecognitionException re) {
 13251  0 
             reportError(re);
 13252  0 
             recover(input,re);
 13253  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13254   
 
 13255   
         }
 13256   
 
 13257  0 
         finally {
 13258   
                 // do for sure before leaving
 13259  702 
         }
 13260  702 
         return retval;
 13261   
     }
 13262   
     // $ANTLR end "verbSimple"
 13263   
 
 13264   
 
 13265  2692 
     public static class path_return extends ParserRuleReturnScope {
 13266   
         Object tree;
 13267  2692 
         public Object getTree() { return tree; }
 13268   
     };
 13269   
 
 13270   
 
 13271   
     // $ANTLR start "path"
 13272   
     // com\\googlecode\\sparkleg\\Sparql.g:403:1: path : pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13273   
     public final SparqlParser.path_return path() throws RecognitionException {
 13274  2692 
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13275  2692 
         retval.start = input.LT(1);
 13276   
 
 13277   
 
 13278  2692 
         Object root_0 = null;
 13279   
 
 13280  2692 
         Token PIPE289=null;
 13281  2692 
         SparqlParser.pathSequence_return pathSequence288 =null;
 13282   
 
 13283  2692 
         SparqlParser.pathSequence_return pathSequence290 =null;
 13284   
 
 13285   
 
 13286  2692 
         Object PIPE289_tree=null;
 13287  2692 
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 13288  2692 
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13289   
         try {
 13290   
             // com\\googlecode\\sparkleg\\Sparql.g:404:5: ( pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13291   
             // com\\googlecode\\sparkleg\\Sparql.g:404:7: pathSequence ( PIPE pathSequence )*
 13292   
             {
 13293  2692 
             pushFollow(FOLLOW_pathSequence_in_path3298);
 13294  2692 
             pathSequence288=pathSequence();
 13295   
 
 13296  2692 
             state._fsp--;
 13297   
 
 13298  2692 
             stream_pathSequence.add(pathSequence288.getTree());
 13299   
 
 13300   
             // com\\googlecode\\sparkleg\\Sparql.g:404:20: ( PIPE pathSequence )*
 13301   
             loop97:
 13302   
             do {
 13303  2712 
                 int alt97=2;
 13304  2712 
                 switch ( input.LA(1) ) {
 13305   
                 case PIPE:
 13306   
                     {
 13307  20 
                     alt97=1;
 13308   
                     }
 13309   
                     break;
 13310   
 
 13311   
                 }
 13312   
 
 13313  2712 
                 switch (alt97) {
 13314   
                     case 1 :
 13315   
                         // com\\googlecode\\sparkleg\\Sparql.g:404:21: PIPE pathSequence
 13316   
                         {
 13317  20 
                         PIPE289=(Token)match(input,PIPE,FOLLOW_PIPE_in_path3301);
 13318  20 
                         stream_PIPE.add(PIPE289);
 13319   
 
 13320   
 
 13321  20 
                         pushFollow(FOLLOW_pathSequence_in_path3303);
 13322  20 
                         pathSequence290=pathSequence();
 13323   
 
 13324  20 
                         state._fsp--;
 13325   
 
 13326  20 
                         stream_pathSequence.add(pathSequence290.getTree());
 13327   
 
 13328   
                         }
 13329  20 
                         break;
 13330   
 
 13331   
                     default :
 13332  2692 
                         break loop97;
 13333   
                 }
 13334  20 
             } while (true);
 13335   
 
 13336   
 
 13337   
             // AST REWRITE
 13338   
             // elements: pathSequence
 13339   
             // token labels:
 13340   
             // rule labels: retval
 13341   
             // token list labels:
 13342   
             // rule list labels:
 13343   
             // wildcard labels:
 13344  2692 
             retval.tree = root_0;
 13345  2692 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13346   
 
 13347  2692 
             root_0 = (Object)adaptor.nil();
 13348   
             // 404:41: -> ^( PATH ( pathSequence )+ )
 13349   
             {
 13350   
                 // com\\googlecode\\sparkleg\\Sparql.g:404:44: ^( PATH ( pathSequence )+ )
 13351   
                 {
 13352  2692 
                 Object root_1 = (Object)adaptor.nil();
 13353  2692 
                 root_1 = (Object)adaptor.becomeRoot(
 13354   
                 (Object)adaptor.create(PATH, "PATH")
 13355   
                 , root_1);
 13356   
 
 13357  2692 
                 if ( !(stream_pathSequence.hasNext()) ) {
 13358  0 
                     throw new RewriteEarlyExitException();
 13359   
                 }
 13360  5404 
                 while ( stream_pathSequence.hasNext() ) {
 13361  2712 
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13362   
 
 13363   
                 }
 13364  2692 
                 stream_pathSequence.reset();
 13365   
 
 13366  2692 
                 adaptor.addChild(root_0, root_1);
 13367   
                 }
 13368   
 
 13369   
             }
 13370   
 
 13371   
 
 13372  2692 
             retval.tree = root_0;
 13373   
 
 13374   
             }
 13375   
 
 13376  2692 
             retval.stop = input.LT(-1);
 13377   
 
 13378   
 
 13379  2692 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13380  2692 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13381   
 
 13382   
         }
 13383  0 
         catch (RecognitionException re) {
 13384  0 
             reportError(re);
 13385  0 
             recover(input,re);
 13386  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13387   
 
 13388   
         }
 13389   
 
 13390  0 
         finally {
 13391   
                 // do for sure before leaving
 13392  2692 
         }
 13393  2692 
         return retval;
 13394   
     }
 13395   
     // $ANTLR end "path"
 13396   
 
 13397   
 
 13398  2712 
     public static class pathSequence_return extends ParserRuleReturnScope {
 13399   
         Object tree;
 13400  2712 
         public Object getTree() { return tree; }
 13401   
     };
 13402   
 
 13403   
 
 13404   
     // $ANTLR start "pathSequence"
 13405   
     // com\\googlecode\\sparkleg\\Sparql.g:407:1: pathSequence : pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13406   
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13407  2712 
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13408  2712 
         retval.start = input.LT(1);
 13409   
 
 13410   
 
 13411  2712 
         Object root_0 = null;
 13412   
 
 13413  2712 
         Token DIVIDE292=null;
 13414  2712 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse291 =null;
 13415   
 
 13416  2712 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse293 =null;
 13417   
 
 13418   
 
 13419  2712 
         Object DIVIDE292_tree=null;
 13420  2712 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13421  2712 
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13422   
         try {
 13423   
             // com\\googlecode\\sparkleg\\Sparql.g:408:5: ( pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13424   
             // com\\googlecode\\sparkleg\\Sparql.g:408:7: pathEltOrInverse ( DIVIDE pathEltOrInverse )*
 13425   
             {
 13426  2712 
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3332);
 13427  2712 
             pathEltOrInverse291=pathEltOrInverse();
 13428   
 
 13429  2712 
             state._fsp--;
 13430   
 
 13431  2712 
             stream_pathEltOrInverse.add(pathEltOrInverse291.getTree());
 13432   
 
 13433   
             // com\\googlecode\\sparkleg\\Sparql.g:408:24: ( DIVIDE pathEltOrInverse )*
 13434   
             loop98:
 13435   
             do {
 13436  2776 
                 int alt98=2;
 13437  2776 
                 switch ( input.LA(1) ) {
 13438   
                 case DIVIDE:
 13439   
                     {
 13440  64 
                     alt98=1;
 13441   
                     }
 13442   
                     break;
 13443   
 
 13444   
                 }
 13445   
 
 13446  2776 
                 switch (alt98) {
 13447   
                     case 1 :
 13448   
                         // com\\googlecode\\sparkleg\\Sparql.g:408:25: DIVIDE pathEltOrInverse
 13449   
                         {
 13450  64 
                         DIVIDE292=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3335);
 13451  64 
                         stream_DIVIDE.add(DIVIDE292);
 13452   
 
 13453   
 
 13454  64 
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3337);
 13455  64 
                         pathEltOrInverse293=pathEltOrInverse();
 13456   
 
 13457  64 
                         state._fsp--;
 13458   
 
 13459  64 
                         stream_pathEltOrInverse.add(pathEltOrInverse293.getTree());
 13460   
 
 13461   
                         }
 13462  64 
                         break;
 13463   
 
 13464   
                     default :
 13465  2712 
                         break loop98;
 13466   
                 }
 13467  64 
             } while (true);
 13468   
 
 13469   
 
 13470   
             // AST REWRITE
 13471   
             // elements: pathEltOrInverse
 13472   
             // token labels:
 13473   
             // rule labels: retval
 13474   
             // token list labels:
 13475   
             // rule list labels:
 13476   
             // wildcard labels:
 13477  2712 
             retval.tree = root_0;
 13478  2712 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13479   
 
 13480  2712 
             root_0 = (Object)adaptor.nil();
 13481   
             // 408:51: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13482   
             {
 13483   
                 // com\\googlecode\\sparkleg\\Sparql.g:408:54: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13484   
                 {
 13485  2712 
                 Object root_1 = (Object)adaptor.nil();
 13486  2712 
                 root_1 = (Object)adaptor.becomeRoot(
 13487   
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13488   
                 , root_1);
 13489   
 
 13490  2712 
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13491  0 
                     throw new RewriteEarlyExitException();
 13492   
                 }
 13493  5488 
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13494  2776 
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13495   
 
 13496   
                 }
 13497  2712 
                 stream_pathEltOrInverse.reset();
 13498   
 
 13499  2712 
                 adaptor.addChild(root_0, root_1);
 13500   
                 }
 13501   
 
 13502   
             }
 13503   
 
 13504   
 
 13505  2712 
             retval.tree = root_0;
 13506   
 
 13507   
             }
 13508   
 
 13509  2712 
             retval.stop = input.LT(-1);
 13510   
 
 13511   
 
 13512  2712 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13513  2712 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13514   
 
 13515   
         }
 13516  0 
         catch (RecognitionException re) {
 13517  0 
             reportError(re);
 13518  0 
             recover(input,re);
 13519  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13520   
 
 13521   
         }
 13522   
 
 13523  0 
         finally {
 13524   
                 // do for sure before leaving
 13525  2712 
         }
 13526  2712 
         return retval;
 13527   
     }
 13528   
     // $ANTLR end "pathSequence"
 13529   
 
 13530   
 
 13531  2776 
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13532   
         Object tree;
 13533  2776 
         public Object getTree() { return tree; }
 13534   
     };
 13535   
 
 13536   
 
 13537   
     // $ANTLR start "pathEltOrInverse"
 13538   
     // com\\googlecode\\sparkleg\\Sparql.g:411:1: pathEltOrInverse : ( INVERSE )? pathElt ;
 13539   
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13540  2776 
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13541  2776 
         retval.start = input.LT(1);
 13542   
 
 13543   
 
 13544  2776 
         Object root_0 = null;
 13545   
 
 13546  2776 
         Token INVERSE294=null;
 13547  2776 
         SparqlParser.pathElt_return pathElt295 =null;
 13548   
 
 13549   
 
 13550  2776 
         Object INVERSE294_tree=null;
 13551   
 
 13552   
         try {
 13553   
             // com\\googlecode\\sparkleg\\Sparql.g:412:5: ( ( INVERSE )? pathElt )
 13554   
             // com\\googlecode\\sparkleg\\Sparql.g:412:7: ( INVERSE )? pathElt
 13555   
             {
 13556  2776 
             root_0 = (Object)adaptor.nil();
 13557   
 
 13558   
 
 13559   
             // com\\googlecode\\sparkleg\\Sparql.g:412:7: ( INVERSE )?
 13560  2776 
             int alt99=2;
 13561  2776 
             switch ( input.LA(1) ) {
 13562   
                 case INVERSE:
 13563   
                     {
 13564  12 
                     alt99=1;
 13565   
                     }
 13566   
                     break;
 13567   
             }
 13568   
 
 13569  2776 
             switch (alt99) {
 13570   
                 case 1 :
 13571   
                     // com\\googlecode\\sparkleg\\Sparql.g:412:7: INVERSE
 13572   
                     {
 13573  12 
                     INVERSE294=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3365);
 13574  12 
                     INVERSE294_tree =
 13575   
                     (Object)adaptor.create(INVERSE294)
 13576   
                     ;
 13577  12 
                     adaptor.addChild(root_0, INVERSE294_tree);
 13578   
 
 13579   
 
 13580   
                     }
 13581   
                     break;
 13582   
 
 13583   
             }
 13584   
 
 13585   
 
 13586  2776 
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3368);
 13587  2776 
             pathElt295=pathElt();
 13588   
 
 13589  2776 
             state._fsp--;
 13590   
 
 13591  2776 
             adaptor.addChild(root_0, pathElt295.getTree());
 13592   
 
 13593   
             }
 13594   
 
 13595  2776 
             retval.stop = input.LT(-1);
 13596   
 
 13597   
 
 13598  2776 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13599  2776 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13600   
 
 13601   
         }
 13602  0 
         catch (RecognitionException re) {
 13603  0 
             reportError(re);
 13604  0 
             recover(input,re);
 13605  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13606   
 
 13607   
         }
 13608   
 
 13609  0 
         finally {
 13610   
                 // do for sure before leaving
 13611  2776 
         }
 13612  2776 
         return retval;
 13613   
     }
 13614   
     // $ANTLR end "pathEltOrInverse"
 13615   
 
 13616   
 
 13617  2776 
     public static class pathElt_return extends ParserRuleReturnScope {
 13618   
         Object tree;
 13619  2776 
         public Object getTree() { return tree; }
 13620   
     };
 13621   
 
 13622   
 
 13623   
     // $ANTLR start "pathElt"
 13624   
     // com\\googlecode\\sparkleg\\Sparql.g:415:1: pathElt : pathPrimary ( pathMod )? ;
 13625   
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13626  2776 
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13627  2776 
         retval.start = input.LT(1);
 13628   
 
 13629   
 
 13630  2776 
         Object root_0 = null;
 13631   
 
 13632  2776 
         SparqlParser.pathPrimary_return pathPrimary296 =null;
 13633   
 
 13634  2776 
         SparqlParser.pathMod_return pathMod297 =null;
 13635   
 
 13636   
 
 13637   
 
 13638   
         try {
 13639   
             // com\\googlecode\\sparkleg\\Sparql.g:416:5: ( pathPrimary ( pathMod )? )
 13640   
             // com\\googlecode\\sparkleg\\Sparql.g:416:7: pathPrimary ( pathMod )?
 13641   
             {
 13642  2776 
             root_0 = (Object)adaptor.nil();
 13643   
 
 13644   
 
 13645  2776 
             pushFollow(FOLLOW_pathPrimary_in_pathElt3396);
 13646  2776 
             pathPrimary296=pathPrimary();
 13647   
 
 13648  2776 
             state._fsp--;
 13649   
 
 13650  2776 
             adaptor.addChild(root_0, pathPrimary296.getTree());
 13651   
 
 13652   
             // com\\googlecode\\sparkleg\\Sparql.g:416:19: ( pathMod )?
 13653  2776 
             int alt100=2;
 13654  2776 
             switch ( input.LA(1) ) {
 13655   
                 case ASTERISK:
 13656   
                 case OPEN_CURLY_BRACE:
 13657   
                 case PLUS:
 13658   
                 case QUESTION_MARK:
 13659   
                     {
 13660  66 
                     alt100=1;
 13661   
                     }
 13662   
                     break;
 13663   
             }
 13664   
 
 13665  2776 
             switch (alt100) {
 13666   
                 case 1 :
 13667   
                     // com\\googlecode\\sparkleg\\Sparql.g:416:19: pathMod
 13668   
                     {
 13669  66 
                     pushFollow(FOLLOW_pathMod_in_pathElt3398);
 13670  66 
                     pathMod297=pathMod();
 13671   
 
 13672  66 
                     state._fsp--;
 13673   
 
 13674  66 
                     adaptor.addChild(root_0, pathMod297.getTree());
 13675   
 
 13676   
                     }
 13677   
                     break;
 13678   
 
 13679   
             }
 13680   
 
 13681   
 
 13682   
             }
 13683   
 
 13684  2776 
             retval.stop = input.LT(-1);
 13685   
 
 13686   
 
 13687  2776 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13688  2776 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13689   
 
 13690   
         }
 13691  0 
         catch (RecognitionException re) {
 13692  0 
             reportError(re);
 13693  0 
             recover(input,re);
 13694  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13695   
 
 13696   
         }
 13697   
 
 13698  0 
         finally {
 13699   
                 // do for sure before leaving
 13700  2776 
         }
 13701  2776 
         return retval;
 13702   
     }
 13703   
     // $ANTLR end "pathElt"
 13704   
 
 13705   
 
 13706  66 
     public static class pathMod_return extends ParserRuleReturnScope {
 13707   
         Object tree;
 13708  66 
         public Object getTree() { return tree; }
 13709   
     };
 13710   
 
 13711   
 
 13712   
     // $ANTLR start "pathMod"
 13713   
     // com\\googlecode\\sparkleg\\Sparql.g:419:1: pathMod : ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) ;
 13714   
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13715  66 
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13716  66 
         retval.start = input.LT(1);
 13717   
 
 13718   
 
 13719  66 
         Object root_0 = null;
 13720   
 
 13721  66 
         Token ASTERISK298=null;
 13722  66 
         Token QUESTION_MARK299=null;
 13723  66 
         Token PLUS300=null;
 13724  66 
         Token OPEN_CURLY_BRACE301=null;
 13725  66 
         Token INTEGER302=null;
 13726  66 
         Token COMMA303=null;
 13727  66 
         Token CLOSE_CURLY_BRACE304=null;
 13728  66 
         Token INTEGER305=null;
 13729  66 
         Token CLOSE_CURLY_BRACE306=null;
 13730  66 
         Token CLOSE_CURLY_BRACE307=null;
 13731  66 
         Token COMMA308=null;
 13732  66 
         Token INTEGER309=null;
 13733  66 
         Token CLOSE_CURLY_BRACE310=null;
 13734   
 
 13735  66 
         Object ASTERISK298_tree=null;
 13736  66 
         Object QUESTION_MARK299_tree=null;
 13737  66 
         Object PLUS300_tree=null;
 13738  66 
         Object OPEN_CURLY_BRACE301_tree=null;
 13739  66 
         Object INTEGER302_tree=null;
 13740  66 
         Object COMMA303_tree=null;
 13741  66 
         Object CLOSE_CURLY_BRACE304_tree=null;
 13742  66 
         Object INTEGER305_tree=null;
 13743  66 
         Object CLOSE_CURLY_BRACE306_tree=null;
 13744  66 
         Object CLOSE_CURLY_BRACE307_tree=null;
 13745  66 
         Object COMMA308_tree=null;
 13746  66 
         Object INTEGER309_tree=null;
 13747  66 
         Object CLOSE_CURLY_BRACE310_tree=null;
 13748   
 
 13749   
         try {
 13750   
             // com\\googlecode\\sparkleg\\Sparql.g:420:5: ( ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) )
 13751   
             // com\\googlecode\\sparkleg\\Sparql.g:420:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13752   
             {
 13753  66 
             root_0 = (Object)adaptor.nil();
 13754   
 
 13755   
 
 13756   
             // com\\googlecode\\sparkleg\\Sparql.g:420:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13757  66 
             int alt104=4;
 13758  66 
             switch ( input.LA(1) ) {
 13759   
             case ASTERISK:
 13760   
                 {
 13761  18 
                 alt104=1;
 13762   
                 }
 13763  18 
                 break;
 13764   
             case QUESTION_MARK:
 13765   
                 {
 13766  2 
                 alt104=2;
 13767   
                 }
 13768  2 
                 break;
 13769   
             case PLUS:
 13770   
                 {
 13771  16 
                 alt104=3;
 13772   
                 }
 13773  16 
                 break;
 13774   
             case OPEN_CURLY_BRACE:
 13775   
                 {
 13776  30 
                 alt104=4;
 13777   
                 }
 13778  30 
                 break;
 13779   
             default:
 13780  0 
                 NoViableAltException nvae =
 13781   
                     new NoViableAltException("", 104, 0, input);
 13782   
 
 13783  0 
                 throw nvae;
 13784   
 
 13785   
             }
 13786   
 
 13787  66 
             switch (alt104) {
 13788   
                 case 1 :
 13789   
                     // com\\googlecode\\sparkleg\\Sparql.g:420:8: ASTERISK
 13790   
                     {
 13791  18 
                     ASTERISK298=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3417);
 13792  18 
                     ASTERISK298_tree =
 13793   
                     (Object)adaptor.create(ASTERISK298)
 13794   
                     ;
 13795  18 
                     adaptor.addChild(root_0, ASTERISK298_tree);
 13796   
 
 13797   
 
 13798   
                     }
 13799  18 
                     break;
 13800   
                 case 2 :
 13801   
                     // com\\googlecode\\sparkleg\\Sparql.g:420:19: QUESTION_MARK
 13802   
                     {
 13803  2 
                     QUESTION_MARK299=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3421);
 13804  2 
                     QUESTION_MARK299_tree =
 13805   
                     (Object)adaptor.create(QUESTION_MARK299)
 13806   
                     ;
 13807  2 
                     adaptor.addChild(root_0, QUESTION_MARK299_tree);
 13808   
 
 13809   
 
 13810   
                     }
 13811  2 
                     break;
 13812   
                 case 3 :
 13813   
                     // com\\googlecode\\sparkleg\\Sparql.g:420:35: PLUS
 13814   
                     {
 13815  16 
                     PLUS300=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3425);
 13816  16 
                     PLUS300_tree =
 13817   
                     (Object)adaptor.create(PLUS300)
 13818   
                     ;
 13819  16 
                     adaptor.addChild(root_0, PLUS300_tree);
 13820   
 
 13821   
 
 13822   
                     }
 13823  16 
                     break;
 13824   
                 case 4 :
 13825   
                     // com\\googlecode\\sparkleg\\Sparql.g:420:42: OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13826   
                     {
 13827  30 
                     OPEN_CURLY_BRACE301=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_pathMod3429);
 13828  30 
                     OPEN_CURLY_BRACE301_tree =
 13829   
                     (Object)adaptor.create(OPEN_CURLY_BRACE301)
 13830   
                     ;
 13831  30 
                     adaptor.addChild(root_0, OPEN_CURLY_BRACE301_tree);
 13832   
 
 13833   
 
 13834   
                     // com\\googlecode\\sparkleg\\Sparql.g:420:59: ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13835  30 
                     int alt103=2;
 13836  30 
                     switch ( input.LA(1) ) {
 13837   
                     case INTEGER:
 13838   
                         {
 13839  28 
                         alt103=1;
 13840   
                         }
 13841  28 
                         break;
 13842   
                     case COMMA:
 13843   
                         {
 13844  2 
                         alt103=2;
 13845   
                         }
 13846  2 
                         break;
 13847   
                     default:
 13848  0 
                         NoViableAltException nvae =
 13849   
                             new NoViableAltException("", 103, 0, input);
 13850   
 
 13851  0 
                         throw nvae;
 13852   
 
 13853   
                     }
 13854   
 
 13855  30 
                     switch (alt103) {
 13856   
                         case 1 :
 13857   
                             // com\\googlecode\\sparkleg\\Sparql.g:420:60: INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13858   
                             {
 13859  28 
                             INTEGER302=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3432);
 13860  28 
                             INTEGER302_tree =
 13861   
                             (Object)adaptor.create(INTEGER302)
 13862   
                             ;
 13863  28 
                             adaptor.addChild(root_0, INTEGER302_tree);
 13864   
 
 13865   
 
 13866   
                             // com\\googlecode\\sparkleg\\Sparql.g:420:68: ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13867  28 
                             int alt102=2;
 13868  28 
                             switch ( input.LA(1) ) {
 13869   
                             case COMMA:
 13870   
                                 {
 13871  10 
                                 alt102=1;
 13872   
                                 }
 13873  10 
                                 break;
 13874   
                             case CLOSE_CURLY_BRACE:
 13875   
                                 {
 13876  18 
                                 alt102=2;
 13877   
                                 }
 13878  18 
                                 break;
 13879   
                             default:
 13880  0 
                                 NoViableAltException nvae =
 13881   
                                     new NoViableAltException("", 102, 0, input);
 13882   
 
 13883  0 
                                 throw nvae;
 13884   
 
 13885   
                             }
 13886   
 
 13887  28 
                             switch (alt102) {
 13888   
                                 case 1 :
 13889   
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:69: COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 13890   
                                     {
 13891  10 
                                     COMMA303=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3435);
 13892  10 
                                     COMMA303_tree =
 13893   
                                     (Object)adaptor.create(COMMA303)
 13894   
                                     ;
 13895  10 
                                     adaptor.addChild(root_0, COMMA303_tree);
 13896   
 
 13897   
 
 13898   
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:75: ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 13899  10 
                                     int alt101=2;
 13900  10 
                                     switch ( input.LA(1) ) {
 13901   
                                     case CLOSE_CURLY_BRACE:
 13902   
                                         {
 13903  6 
                                         alt101=1;
 13904   
                                         }
 13905  6 
                                         break;
 13906   
                                     case INTEGER:
 13907   
                                         {
 13908  4 
                                         alt101=2;
 13909   
                                         }
 13910  4 
                                         break;
 13911   
                                     default:
 13912  0 
                                         NoViableAltException nvae =
 13913   
                                             new NoViableAltException("", 101, 0, input);
 13914   
 
 13915  0 
                                         throw nvae;
 13916   
 
 13917   
                                     }
 13918   
 
 13919  10 
                                     switch (alt101) {
 13920   
                                         case 1 :
 13921   
                                             // com\\googlecode\\sparkleg\\Sparql.g:420:76: CLOSE_CURLY_BRACE
 13922   
                                             {
 13923  6 
                                             CLOSE_CURLY_BRACE304=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3438);
 13924  6 
                                             CLOSE_CURLY_BRACE304_tree =
 13925   
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE304)
 13926   
                                             ;
 13927  6 
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE304_tree);
 13928   
 
 13929   
 
 13930   
                                             }
 13931  6 
                                             break;
 13932   
                                         case 2 :
 13933   
                                             // com\\googlecode\\sparkleg\\Sparql.g:420:96: INTEGER CLOSE_CURLY_BRACE
 13934   
                                             {
 13935  4 
                                             INTEGER305=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3442);
 13936  4 
                                             INTEGER305_tree =
 13937   
                                             (Object)adaptor.create(INTEGER305)
 13938   
                                             ;
 13939  4 
                                             adaptor.addChild(root_0, INTEGER305_tree);
 13940   
 
 13941   
 
 13942  4 
                                             CLOSE_CURLY_BRACE306=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3444);
 13943  4 
                                             CLOSE_CURLY_BRACE306_tree =
 13944   
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE306)
 13945   
                                             ;
 13946  4 
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE306_tree);
 13947   
 
 13948   
 
 13949   
                                             }
 13950   
                                             break;
 13951   
 
 13952   
                                     }
 13953   
 
 13954   
 
 13955   
                                     }
 13956  10 
                                     break;
 13957   
                                 case 2 :
 13958   
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:125: CLOSE_CURLY_BRACE
 13959   
                                     {
 13960  18 
                                     CLOSE_CURLY_BRACE307=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3449);
 13961  18 
                                     CLOSE_CURLY_BRACE307_tree =
 13962   
                                     (Object)adaptor.create(CLOSE_CURLY_BRACE307)
 13963   
                                     ;
 13964  18 
                                     adaptor.addChild(root_0, CLOSE_CURLY_BRACE307_tree);
 13965   
 
 13966   
 
 13967   
                                     }
 13968   
                                     break;
 13969   
 
 13970   
                             }
 13971   
 
 13972   
 
 13973   
                             }
 13974  28 
                             break;
 13975   
                         case 2 :
 13976   
                             // com\\googlecode\\sparkleg\\Sparql.g:420:146: COMMA INTEGER CLOSE_CURLY_BRACE
 13977   
                             {
 13978  2 
                             COMMA308=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3454);
 13979  2 
                             COMMA308_tree =
 13980   
                             (Object)adaptor.create(COMMA308)
 13981   
                             ;
 13982  2 
                             adaptor.addChild(root_0, COMMA308_tree);
 13983   
 
 13984   
 
 13985  2 
                             INTEGER309=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3456);
 13986  2 
                             INTEGER309_tree =
 13987   
                             (Object)adaptor.create(INTEGER309)
 13988   
                             ;
 13989  2 
                             adaptor.addChild(root_0, INTEGER309_tree);
 13990   
 
 13991   
 
 13992  2 
                             CLOSE_CURLY_BRACE310=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3458);
 13993  2 
                             CLOSE_CURLY_BRACE310_tree =
 13994   
                             (Object)adaptor.create(CLOSE_CURLY_BRACE310)
 13995   
                             ;
 13996  2 
                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE310_tree);
 13997   
 
 13998   
 
 13999   
                             }
 14000   
                             break;
 14001   
 
 14002   
                     }
 14003   
 
 14004   
 
 14005   
                     }
 14006   
                     break;
 14007   
 
 14008   
             }
 14009   
 
 14010   
 
 14011   
             }
 14012   
 
 14013  66 
             retval.stop = input.LT(-1);
 14014   
 
 14015   
 
 14016  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14017  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14018   
 
 14019   
         }
 14020  0 
         catch (RecognitionException re) {
 14021  0 
             reportError(re);
 14022  0 
             recover(input,re);
 14023  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14024   
 
 14025   
         }
 14026   
 
 14027  0 
         finally {
 14028   
                 // do for sure before leaving
 14029  66 
         }
 14030  66 
         return retval;
 14031   
     }
 14032   
     // $ANTLR end "pathMod"
 14033   
 
 14034   
 
 14035  2776 
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14036   
         Object tree;
 14037  2776 
         public Object getTree() { return tree; }
 14038   
     };
 14039   
 
 14040   
 
 14041   
     // $ANTLR start "pathPrimary"
 14042   
     // com\\googlecode\\sparkleg\\Sparql.g:423:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) );
 14043   
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14044  2776 
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14045  2776 
         retval.start = input.LT(1);
 14046   
 
 14047   
 
 14048  2776 
         Object root_0 = null;
 14049   
 
 14050  2776 
         Token A312=null;
 14051  2776 
         Token NEGATION313=null;
 14052  2776 
         Token OPEN_BRACE315=null;
 14053  2776 
         Token CLOSE_BRACE317=null;
 14054  2776 
         SparqlParser.iriRef_return iriRef311 =null;
 14055   
 
 14056  2776 
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet314 =null;
 14057   
 
 14058  2776 
         SparqlParser.path_return path316 =null;
 14059   
 
 14060   
 
 14061  2776 
         Object A312_tree=null;
 14062  2776 
         Object NEGATION313_tree=null;
 14063  2776 
         Object OPEN_BRACE315_tree=null;
 14064  2776 
         Object CLOSE_BRACE317_tree=null;
 14065  2776 
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14066  2776 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14067  2776 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14068  2776 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14069  2776 
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14070  2776 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14071  2776 
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14072   
         try {
 14073   
             // com\\googlecode\\sparkleg\\Sparql.g:424:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) )
 14074  2776 
             int alt105=4;
 14075  2776 
             switch ( input.LA(1) ) {
 14076   
             case IRI_REF:
 14077   
             case PNAME_LN:
 14078   
             case PNAME_NS:
 14079   
                 {
 14080  2686 
                 alt105=1;
 14081   
                 }
 14082  2686 
                 break;
 14083   
             case A:
 14084   
                 {
 14085  64 
                 alt105=2;
 14086   
                 }
 14087  64 
                 break;
 14088   
             case NEGATION:
 14089   
                 {
 14090  6 
                 alt105=3;
 14091   
                 }
 14092  6 
                 break;
 14093   
             case OPEN_BRACE:
 14094   
                 {
 14095  20 
                 alt105=4;
 14096   
                 }
 14097  20 
                 break;
 14098   
             default:
 14099  0 
                 NoViableAltException nvae =
 14100   
                     new NoViableAltException("", 105, 0, input);
 14101   
 
 14102  0 
                 throw nvae;
 14103   
 
 14104   
             }
 14105   
 
 14106  2776 
             switch (alt105) {
 14107   
                 case 1 :
 14108   
                     // com\\googlecode\\sparkleg\\Sparql.g:424:7: iriRef
 14109   
                     {
 14110  2686 
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3477);
 14111  2686 
                     iriRef311=iriRef();
 14112   
 
 14113  2686 
                     state._fsp--;
 14114   
 
 14115  2686 
                     stream_iriRef.add(iriRef311.getTree());
 14116   
 
 14117   
                     // AST REWRITE
 14118   
                     // elements: iriRef
 14119   
                     // token labels:
 14120   
                     // rule labels: retval
 14121   
                     // token list labels:
 14122   
                     // rule list labels:
 14123   
                     // wildcard labels:
 14124  2686 
                     retval.tree = root_0;
 14125  2686 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14126   
 
 14127  2686 
                     root_0 = (Object)adaptor.nil();
 14128   
                     // 424:14: -> ^( PATH_PRIMARY iriRef )
 14129   
                     {
 14130   
                         // com\\googlecode\\sparkleg\\Sparql.g:424:17: ^( PATH_PRIMARY iriRef )
 14131   
                         {
 14132  2686 
                         Object root_1 = (Object)adaptor.nil();
 14133  2686 
                         root_1 = (Object)adaptor.becomeRoot(
 14134   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14135   
                         , root_1);
 14136   
 
 14137  2686 
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14138   
 
 14139  2686 
                         adaptor.addChild(root_0, root_1);
 14140   
                         }
 14141   
 
 14142   
                     }
 14143   
 
 14144   
 
 14145  2686 
                     retval.tree = root_0;
 14146   
 
 14147   
                     }
 14148  2686 
                     break;
 14149   
                 case 2 :
 14150   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:7: A
 14151   
                     {
 14152  64 
                     A312=(Token)match(input,A,FOLLOW_A_in_pathPrimary3493);
 14153  64 
                     stream_A.add(A312);
 14154   
 
 14155   
 
 14156   
                     // AST REWRITE
 14157   
                     // elements: A
 14158   
                     // token labels:
 14159   
                     // rule labels: retval
 14160   
                     // token list labels:
 14161   
                     // rule list labels:
 14162   
                     // wildcard labels:
 14163  64 
                     retval.tree = root_0;
 14164  64 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14165   
 
 14166  64 
                     root_0 = (Object)adaptor.nil();
 14167   
                     // 425:9: -> ^( PATH_PRIMARY A )
 14168   
                     {
 14169   
                         // com\\googlecode\\sparkleg\\Sparql.g:425:12: ^( PATH_PRIMARY A )
 14170   
                         {
 14171  64 
                         Object root_1 = (Object)adaptor.nil();
 14172  64 
                         root_1 = (Object)adaptor.becomeRoot(
 14173   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14174   
                         , root_1);
 14175   
 
 14176  64 
                         adaptor.addChild(root_1,
 14177   
                         stream_A.nextNode()
 14178   
                         );
 14179   
 
 14180  64 
                         adaptor.addChild(root_0, root_1);
 14181   
                         }
 14182   
 
 14183   
                     }
 14184   
 
 14185   
 
 14186  64 
                     retval.tree = root_0;
 14187   
 
 14188   
                     }
 14189  64 
                     break;
 14190   
                 case 3 :
 14191   
                     // com\\googlecode\\sparkleg\\Sparql.g:426:7: NEGATION pathNegatedPropertySet
 14192   
                     {
 14193  6 
                     NEGATION313=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3509);
 14194  6 
                     stream_NEGATION.add(NEGATION313);
 14195   
 
 14196   
 
 14197  6 
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3511);
 14198  6 
                     pathNegatedPropertySet314=pathNegatedPropertySet();
 14199   
 
 14200  6 
                     state._fsp--;
 14201   
 
 14202  6 
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet314.getTree());
 14203   
 
 14204   
                     // AST REWRITE
 14205   
                     // elements: NEGATION, pathNegatedPropertySet
 14206   
                     // token labels:
 14207   
                     // rule labels: retval
 14208   
                     // token list labels:
 14209   
                     // rule list labels:
 14210   
                     // wildcard labels:
 14211  6 
                     retval.tree = root_0;
 14212  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14213   
 
 14214  6 
                     root_0 = (Object)adaptor.nil();
 14215   
                     // 426:39: -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14216   
                     {
 14217   
                         // com\\googlecode\\sparkleg\\Sparql.g:426:42: ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14218   
                         {
 14219  6 
                         Object root_1 = (Object)adaptor.nil();
 14220  6 
                         root_1 = (Object)adaptor.becomeRoot(
 14221   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14222   
                         , root_1);
 14223   
 
 14224  6 
                         adaptor.addChild(root_1,
 14225   
                         stream_NEGATION.nextNode()
 14226   
                         );
 14227   
 
 14228  6 
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14229   
 
 14230  6 
                         adaptor.addChild(root_0, root_1);
 14231   
                         }
 14232   
 
 14233   
                     }
 14234   
 
 14235   
 
 14236  6 
                     retval.tree = root_0;
 14237   
 
 14238   
                     }
 14239  6 
                     break;
 14240   
                 case 4 :
 14241   
                     // com\\googlecode\\sparkleg\\Sparql.g:427:7: OPEN_BRACE path CLOSE_BRACE
 14242   
                     {
 14243  20 
                     OPEN_BRACE315=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathPrimary3529);
 14244  20 
                     stream_OPEN_BRACE.add(OPEN_BRACE315);
 14245   
 
 14246   
 
 14247  20 
                     pushFollow(FOLLOW_path_in_pathPrimary3531);
 14248  20 
                     path316=path();
 14249   
 
 14250  20 
                     state._fsp--;
 14251   
 
 14252  20 
                     stream_path.add(path316.getTree());
 14253   
 
 14254  20 
                     CLOSE_BRACE317=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathPrimary3533);
 14255  20 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE317);
 14256   
 
 14257   
 
 14258   
                     // AST REWRITE
 14259   
                     // elements: path
 14260   
                     // token labels:
 14261   
                     // rule labels: retval
 14262   
                     // token list labels:
 14263   
                     // rule list labels:
 14264   
                     // wildcard labels:
 14265  20 
                     retval.tree = root_0;
 14266  20 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14267   
 
 14268  20 
                     root_0 = (Object)adaptor.nil();
 14269   
                     // 427:35: -> ^( PATH_PRIMARY path )
 14270   
                     {
 14271   
                         // com\\googlecode\\sparkleg\\Sparql.g:427:38: ^( PATH_PRIMARY path )
 14272   
                         {
 14273  20 
                         Object root_1 = (Object)adaptor.nil();
 14274  20 
                         root_1 = (Object)adaptor.becomeRoot(
 14275   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14276   
                         , root_1);
 14277   
 
 14278  20 
                         adaptor.addChild(root_1, stream_path.nextTree());
 14279   
 
 14280  20 
                         adaptor.addChild(root_0, root_1);
 14281   
                         }
 14282   
 
 14283   
                     }
 14284   
 
 14285   
 
 14286  20 
                     retval.tree = root_0;
 14287   
 
 14288   
                     }
 14289   
                     break;
 14290   
 
 14291   
             }
 14292  2776 
             retval.stop = input.LT(-1);
 14293   
 
 14294   
 
 14295  2776 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14296  2776 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14297   
 
 14298   
         }
 14299  0 
         catch (RecognitionException re) {
 14300  0 
             reportError(re);
 14301  0 
             recover(input,re);
 14302  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14303   
 
 14304   
         }
 14305   
 
 14306  0 
         finally {
 14307   
                 // do for sure before leaving
 14308  2776 
         }
 14309  2776 
         return retval;
 14310   
     }
 14311   
     // $ANTLR end "pathPrimary"
 14312   
 
 14313   
 
 14314  6 
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14315   
         Object tree;
 14316  6 
         public Object getTree() { return tree; }
 14317   
     };
 14318   
 
 14319   
 
 14320   
     // $ANTLR start "pathNegatedPropertySet"
 14321   
     // com\\googlecode\\sparkleg\\Sparql.g:430:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14322   
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14323  6 
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14324  6 
         retval.start = input.LT(1);
 14325   
 
 14326   
 
 14327  6 
         Object root_0 = null;
 14328   
 
 14329  6 
         Token OPEN_BRACE319=null;
 14330  6 
         Token PIPE321=null;
 14331  6 
         Token CLOSE_BRACE323=null;
 14332  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet318 =null;
 14333   
 
 14334  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet320 =null;
 14335   
 
 14336  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet322 =null;
 14337   
 
 14338   
 
 14339  6 
         Object OPEN_BRACE319_tree=null;
 14340  6 
         Object PIPE321_tree=null;
 14341  6 
         Object CLOSE_BRACE323_tree=null;
 14342  6 
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 14343  6 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14344  6 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14345  6 
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14346   
         try {
 14347   
             // com\\googlecode\\sparkleg\\Sparql.g:431:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14348  3 
             int alt108=2;
 14349  3 
             switch ( input.LA(1) ) {
 14350   
             case A:
 14351  3 
             case INVERSE:
 14352  3 
             case IRI_REF:
 14353   
             case PNAME_LN:
 14354   
             case PNAME_NS:
 14355   
                 {
 14356  0 
                 alt108=1;
 14357   
                 }
 14358  0 
                 break;
 14359   
             case OPEN_BRACE:
 14360   
                 {
 14361  3 
                 alt108=2;
 14362   
                 }
 14363  3 
                 break;
 14364  3 
             default:
 14365  0 
                 NoViableAltException nvae =
 14366  3 
                     new NoViableAltException("", 108, 0, input);
 14367   
 
 14368  0 
                 throw nvae;
 14369   
 
 14370   
             }
 14371   
 
 14372  3 
             switch (alt108) {
 14373   
                 case 1 :
 14374   
                     // com\\googlecode\\sparkleg\\Sparql.g:431:7: pathOneInPropertySet
 14375  3 
                     {
 14376  0 
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3558);
 14377  0 
                     pathOneInPropertySet318=pathOneInPropertySet();
 14378   
 
 14379  0 
                     state._fsp--;
 14380   
 
 14381  0 
                     stream_pathOneInPropertySet.add(pathOneInPropertySet318.getTree());
 14382   
 
 14383   
                     // AST REWRITE
 14384   
                     // elements: pathOneInPropertySet
 14385   
                     // token labels:
 14386   
                     // rule labels: retval
 14387   
                     // token list labels:
 14388   
                     // rule list labels:
 14389   
                     // wildcard labels:
 14390  0 
                     retval.tree = root_0;
 14391  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14392  3 
 
 14393  0 
                     root_0 = (Object)adaptor.nil();
 14394   
                     // 431:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14395   
                     {
 14396  3 
                         // com\\googlecode\\sparkleg\\Sparql.g:431:31: ^( PATH_NEGATED pathOneInPropertySet )
 14397  3 
                         {
 14398  0 
                         Object root_1 = (Object)adaptor.nil();
 14399  0 
                         root_1 = (Object)adaptor.becomeRoot(
 14400   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14401   
                         , root_1);
 14402   
 
 14403  0 
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14404  3 
 
 14405  0 
                         adaptor.addChild(root_0, root_1);
 14406   
                         }
 14407   
 
 14408   
                     }
 14409  3 
 
 14410   
 
 14411  0 
                     retval.tree = root_0;
 14412   
 
 14413  3 
                     }
 14414  3 
                     break;
 14415   
                 case 2 :
 14416  3 
                     // com\\googlecode\\sparkleg\\Sparql.g:432:7: OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE
 14417   
                     {
 14418  6 
                     OPEN_BRACE319=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3574);
 14419  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE319);
 14420   
 
 14421   
 
 14422   
                     // com\\googlecode\\sparkleg\\Sparql.g:432:18: ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )?
 14423  9 
                     int alt107=2;
 14424  9 
                     switch ( input.LA(1) ) {
 14425   
                         case A:
 14426   
                         case INVERSE:
 14427  3 
                         case IRI_REF:
 14428   
                         case PNAME_LN:
 14429   
                         case PNAME_NS:
 14430   
                             {
 14431  3 
                             alt107=1;
 14432   
                             }
 14433  6 
                             break;
 14434   
                     }
 14435   
 
 14436  3 
                     switch (alt107) {
 14437  3 
                         case 1 :
 14438  3 
                             // com\\googlecode\\sparkleg\\Sparql.g:432:19: pathOneInPropertySet ( PIPE pathOneInPropertySet )*
 14439   
                             {
 14440  3 
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3577);
 14441  6 
                             pathOneInPropertySet320=pathOneInPropertySet();
 14442  3 
 
 14443  3 
                             state._fsp--;
 14444  3 
 
 14445  3 
                             stream_pathOneInPropertySet.add(pathOneInPropertySet320.getTree());
 14446  3 
 
 14447   
                             // com\\googlecode\\sparkleg\\Sparql.g:432:40: ( PIPE pathOneInPropertySet )*
 14448   
                             loop106:
 14449  3 
                             do {
 14450  6 
                                 int alt106=2;
 14451  6 
                                 switch ( input.LA(1) ) {
 14452  3 
                                 case PIPE:
 14453   
                                     {
 14454  6 
                                     alt106=1;
 14455   
                                     }
 14456   
                                     break;
 14457   
 
 14458   
                                 }
 14459   
 
 14460  6 
                                 switch (alt106) {
 14461   
                                     case 1 :
 14462   
                                         // com\\googlecode\\sparkleg\\Sparql.g:432:41: PIPE pathOneInPropertySet
 14463  3 
                                         {
 14464  6 
                                         PIPE321=(Token)match(input,PIPE,FOLLOW_PIPE_in_pathNegatedPropertySet3580);
 14465  3 
                                         stream_PIPE.add(PIPE321);
 14466   
 
 14467   
 
 14468  3 
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3582);
 14469  3 
                                         pathOneInPropertySet322=pathOneInPropertySet();
 14470   
 
 14471  3 
                                         state._fsp--;
 14472   
 
 14473  3 
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet322.getTree());
 14474   
 
 14475   
                                         }
 14476  3 
                                         break;
 14477   
 
 14478   
                                     default :
 14479  3 
                                         break loop106;
 14480  3 
                                 }
 14481  6 
                             } while (true);
 14482   
 
 14483  3 
 
 14484   
                             }
 14485   
                             break;
 14486   
 
 14487   
                     }
 14488  3 
 
 14489  3 
 
 14490  3 
                     CLOSE_BRACE323=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3588);
 14491  3 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE323);
 14492   
 
 14493  3 
 
 14494   
                     // AST REWRITE
 14495   
                     // elements: pathOneInPropertySet
 14496  9 
                     // token labels:
 14497  6 
                     // rule labels: retval
 14498   
                     // token list labels:
 14499   
                     // rule list labels:
 14500  3 
                     // wildcard labels:
 14501  3 
                     retval.tree = root_0;
 14502  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14503   
 
 14504  3 
                     root_0 = (Object)adaptor.nil();
 14505   
                     // 432:83: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14506   
                     {
 14507   
                         // com\\googlecode\\sparkleg\\Sparql.g:432:86: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14508  3 
                         {
 14509  3 
                         Object root_1 = (Object)adaptor.nil();
 14510  3 
                         root_1 = (Object)adaptor.becomeRoot(
 14511   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14512  3 
                         , root_1);
 14513   
 
 14514  3 
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14515  3 
                             throw new RewriteEarlyExitException();
 14516  3 
                         }
 14517  9 
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14518  6 
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14519   
 
 14520   
                         }
 14521  3 
                         stream_pathOneInPropertySet.reset();
 14522   
 
 14523  3 
                         adaptor.addChild(root_0, root_1);
 14524   
                         }
 14525   
 
 14526   
                     }
 14527   
 
 14528  3 
 
 14529  6 
                     retval.tree = root_0;
 14530   
 
 14531   
                     }
 14532   
                     break;
 14533   
 
 14534  6 
             }
 14535  3 
             retval.stop = input.LT(-1);
 14536  6 
 
 14537   
 
 14538  3 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14539  3 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14540   
 
 14541   
         }
 14542  0 
         catch (RecognitionException re) {
 14543  6 
             reportError(re);
 14544  6 
             recover(input,re);
 14545  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14546   
 
 14547  6 
         }
 14548   
 
 14549  6 
         finally {
 14550  6 
                 // do for sure before leaving
 14551  9 
         }
 14552  3 
         return retval;
 14553   
     }
 14554  6 
     // $ANTLR end "pathNegatedPropertySet"
 14555  6 
 
 14556   
 
 14557  6 
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14558   
         Object tree;
 14559  6 
         public Object getTree() { return tree; }
 14560   
     };
 14561  6 
 
 14562   
 
 14563   
     // $ANTLR start "pathOneInPropertySet"
 14564   
     // com\\googlecode\\sparkleg\\Sparql.g:435:1: pathOneInPropertySet : ( INVERSE )? ( iriRef | A ) ;
 14565  6 
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14566  12 
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14567  6 
         retval.start = input.LT(1);
 14568   
 
 14569  2 
 
 14570  6 
         Object root_0 = null;
 14571   
 
 14572  6 
         Token INVERSE324=null;
 14573  6 
         Token A326=null;
 14574  12 
         SparqlParser.iriRef_return iriRef325 =null;
 14575   
 
 14576   
 
 14577  6 
         Object INVERSE324_tree=null;
 14578  8 
         Object A326_tree=null;
 14579  2 
 
 14580   
         try {
 14581   
             // com\\googlecode\\sparkleg\\Sparql.g:436:5: ( ( INVERSE )? ( iriRef | A ) )
 14582  2 
             // com\\googlecode\\sparkleg\\Sparql.g:436:7: ( INVERSE )? ( iriRef | A )
 14583   
             {
 14584  6 
             root_0 = (Object)adaptor.nil();
 14585   
 
 14586   
 
 14587   
             // com\\googlecode\\sparkleg\\Sparql.g:436:7: ( INVERSE )?
 14588  6 
             int alt109=2;
 14589  6 
             switch ( input.LA(1) ) {
 14590   
                 case INVERSE:
 14591   
                     {
 14592  8 
                     alt109=1;
 14593  6 
                     }
 14594   
                     break;
 14595   
             }
 14596   
 
 14597  6 
             switch (alt109) {
 14598  6 
                 case 1 :
 14599   
                     // com\\googlecode\\sparkleg\\Sparql.g:436:7: INVERSE
 14600  6 
                     {
 14601  2 
                     INVERSE324=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3617);
 14602  2 
                     INVERSE324_tree =
 14603   
                     (Object)adaptor.create(INVERSE324)
 14604   
                     ;
 14605  2 
                     adaptor.addChild(root_0, INVERSE324_tree);
 14606   
 
 14607   
 
 14608   
                     }
 14609   
                     break;
 14610   
 
 14611   
             }
 14612   
 
 14613   
 
 14614  6 
             // com\\googlecode\\sparkleg\\Sparql.g:436:16: ( iriRef | A )
 14615  6 
             int alt110=2;
 14616  6 
             switch ( input.LA(1) ) {
 14617   
             case IRI_REF:
 14618  6 
             case PNAME_LN:
 14619  6 
             case PNAME_NS:
 14620   
                 {
 14621  12 
                 alt110=1;
 14622   
                 }
 14623  12 
                 break;
 14624   
             case A:
 14625   
                 {
 14626  6 
                 alt110=2;
 14627   
                 }
 14628  0 
                 break;
 14629   
             default:
 14630  0 
                 NoViableAltException nvae =
 14631   
                     new NoViableAltException("", 110, 0, input);
 14632   
 
 14633  0 
                 throw nvae;
 14634   
 
 14635   
             }
 14636   
 
 14637  6 
             switch (alt110) {
 14638   
                 case 1 :
 14639   
                     // com\\googlecode\\sparkleg\\Sparql.g:436:17: iriRef
 14640   
                     {
 14641  6 
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3621);
 14642  6 
                     iriRef325=iriRef();
 14643   
 
 14644  6 
                     state._fsp--;
 14645  6 
 
 14646  6 
                     adaptor.addChild(root_0, iriRef325.getTree());
 14647   
 
 14648  6 
                     }
 14649  12 
                     break;
 14650   
                 case 2 :
 14651   
                     // com\\googlecode\\sparkleg\\Sparql.g:436:26: A
 14652   
                     {
 14653  0 
                     A326=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3625);
 14654  0 
                     A326_tree =
 14655   
                     (Object)adaptor.create(A326)
 14656   
                     ;
 14657  0 
                     adaptor.addChild(root_0, A326_tree);
 14658   
 
 14659   
 
 14660   
                     }
 14661  6 
                     break;
 14662  6 
 
 14663   
             }
 14664   
 
 14665   
 
 14666   
             }
 14667  29 
 
 14668  6 
             retval.stop = input.LT(-1);
 14669  29 
 
 14670   
 
 14671  6 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14672  6 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14673   
 
 14674   
         }
 14675  0 
         catch (RecognitionException re) {
 14676  29 
             reportError(re);
 14677  29 
             recover(input,re);
 14678  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14679   
 
 14680  29 
         }
 14681   
 
 14682  29 
         finally {
 14683  29 
                 // do for sure before leaving
 14684  35 
         }
 14685  35 
         return retval;
 14686  29 
     }
 14687   
     // $ANTLR end "pathOneInPropertySet"
 14688  29 
 
 14689   
 
 14690  29 
     public static class triplesNode_return extends ParserRuleReturnScope {
 14691  29 
         Object tree;
 14692  29 
         public Object getTree() { return tree; }
 14693  29 
     };
 14694  29 
 
 14695  29 
 
 14696  29 
     // $ANTLR start "triplesNode"
 14697  29 
     // com\\googlecode\\sparkleg\\Sparql.g:439:1: triplesNode : ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 14698  29 
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 14699  58 
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 14700  58 
         retval.start = input.LT(1);
 14701   
 
 14702   
 
 14703  58 
         Object root_0 = null;
 14704  29 
 
 14705  29 
         Token OPEN_BRACE327=null;
 14706  29 
         Token CLOSE_BRACE329=null;
 14707  43 
         Token OPEN_SQUARE_BRACKET330=null;
 14708  29 
         Token CLOSE_SQUARE_BRACKET332=null;
 14709  43 
         SparqlParser.graphNode_return graphNode328 =null;
 14710   
 
 14711  29 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty331 =null;
 14712  15 
 
 14713   
 
 14714  44 
         Object OPEN_BRACE327_tree=null;
 14715  29 
         Object CLOSE_BRACE329_tree=null;
 14716  29 
         Object OPEN_SQUARE_BRACKET330_tree=null;
 14717  29 
         Object CLOSE_SQUARE_BRACKET332_tree=null;
 14718  29 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14719  29 
         RewriteRuleTokenStream stream_OPEN_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token OPEN_SQUARE_BRACKET");
 14720  29 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14721  29 
         RewriteRuleTokenStream stream_CLOSE_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token CLOSE_SQUARE_BRACKET");
 14722  29 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 14723  58 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 14724   
         try {
 14725   
             // com\\googlecode\\sparkleg\\Sparql.g:440:5: ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 14726  29 
             int alt112=2;
 14727  43 
             switch ( input.LA(1) ) {
 14728  14 
             case OPEN_BRACE:
 14729   
                 {
 14730  14 
                 alt112=1;
 14731   
                 }
 14732  28 
                 break;
 14733   
             case OPEN_SQUARE_BRACKET:
 14734   
                 {
 14735  48 
                 alt112=2;
 14736  33 
                 }
 14737  15 
                 break;
 14738   
             default:
 14739  0 
                 NoViableAltException nvae =
 14740   
                     new NoViableAltException("", 112, 0, input);
 14741   
 
 14742  0 
                 throw nvae;
 14743   
 
 14744   
             }
 14745   
 
 14746  29 
             switch (alt112) {
 14747   
                 case 1 :
 14748   
                     // com\\googlecode\\sparkleg\\Sparql.g:440:7: OPEN_BRACE ( graphNode )+ CLOSE_BRACE
 14749   
                     {
 14750  14 
                     OPEN_BRACE327=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_triplesNode3644);
 14751  14 
                     stream_OPEN_BRACE.add(OPEN_BRACE327);
 14752   
 
 14753   
 
 14754   
                     // com\\googlecode\\sparkleg\\Sparql.g:440:18: ( graphNode )+
 14755  14 
                     int cnt111=0;
 14756   
                     loop111:
 14757   
                     do {
 14758  33 
                         int alt111=2;
 14759  33 
                         switch ( input.LA(1) ) {
 14760   
                         case BLANK_NODE_LABEL:
 14761  19 
                         case DECIMAL:
 14762   
                         case DECIMAL_NEGATIVE:
 14763   
                         case DECIMAL_POSITIVE:
 14764   
                         case DOUBLE:
 14765   
                         case DOUBLE_NEGATIVE:
 14766   
                         case DOUBLE_POSITIVE:
 14767  33 
                         case FALSE:
 14768   
                         case INTEGER:
 14769   
                         case INTEGER_NEGATIVE:
 14770   
                         case INTEGER_POSITIVE:
 14771  19 
                         case IRI_REF:
 14772  19 
                         case OPEN_BRACE:
 14773   
                         case OPEN_SQUARE_BRACKET:
 14774  19 
                         case PNAME_LN:
 14775   
                         case PNAME_NS:
 14776  19 
                         case STRING_LITERAL1:
 14777   
                         case STRING_LITERAL2:
 14778   
                         case STRING_LITERAL_LONG1:
 14779  19 
                         case STRING_LITERAL_LONG2:
 14780   
                         case TRUE:
 14781   
                         case VAR1:
 14782  14 
                         case VAR2:
 14783   
                             {
 14784  19 
                             alt111=1;
 14785   
                             }
 14786   
                             break;
 14787  19 
 
 14788  19 
                         }
 14789   
 
 14790  33 
                         switch (alt111) {
 14791  14 
                             case 1 :
 14792  14 
                                 // com\\googlecode\\sparkleg\\Sparql.g:440:18: graphNode
 14793   
                                 {
 14794  19 
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3646);
 14795  19 
                                 graphNode328=graphNode();
 14796   
 
 14797  19 
                                 state._fsp--;
 14798   
 
 14799  19 
                                 stream_graphNode.add(graphNode328.getTree());
 14800   
 
 14801   
                                 }
 14802  33 
                                 break;
 14803  14 
 
 14804   
                             default :
 14805  28 
                                 if ( cnt111 >= 1 ) break loop111;
 14806  0 
                                 EarlyExitException eee =
 14807   
                                     new EarlyExitException(111, input);
 14808  0 
                                 throw eee;
 14809   
                         }
 14810  33 
                         cnt111++;
 14811  33 
                     } while (true);
 14812   
 
 14813   
 
 14814  14 
                     CLOSE_BRACE329=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_triplesNode3649);
 14815  28 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE329);
 14816   
 
 14817   
 
 14818  33 
                     // AST REWRITE
 14819  19 
                     // elements: graphNode
 14820   
                     // token labels:
 14821   
                     // rule labels: retval
 14822  14 
                     // token list labels:
 14823   
                     // rule list labels:
 14824  14 
                     // wildcard labels:
 14825  14 
                     retval.tree = root_0;
 14826  14 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14827   
 
 14828  14 
                     root_0 = (Object)adaptor.nil();
 14829   
                     // 440:41: -> ^( COLLECTION ( graphNode )+ )
 14830  14 
                     {
 14831   
                         // com\\googlecode\\sparkleg\\Sparql.g:440:44: ^( COLLECTION ( graphNode )+ )
 14832   
                         {
 14833  28 
                         Object root_1 = (Object)adaptor.nil();
 14834  14 
                         root_1 = (Object)adaptor.becomeRoot(
 14835   
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 14836   
                         , root_1);
 14837  15 
 
 14838  29 
                         if ( !(stream_graphNode.hasNext()) ) {
 14839  0 
                             throw new RewriteEarlyExitException();
 14840   
                         }
 14841  48 
                         while ( stream_graphNode.hasNext() ) {
 14842  34 
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 14843   
 
 14844  15 
                         }
 14845  14 
                         stream_graphNode.reset();
 14846  15 
 
 14847  14 
                         adaptor.addChild(root_0, root_1);
 14848  15 
                         }
 14849  15 
 
 14850   
                     }
 14851   
 
 14852   
 
 14853  14 
                     retval.tree = root_0;
 14854   
 
 14855   
                     }
 14856  14 
                     break;
 14857   
                 case 2 :
 14858   
                     // com\\googlecode\\sparkleg\\Sparql.g:441:7: OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET
 14859  15 
                     {
 14860  30 
                     OPEN_SQUARE_BRACKET330=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3666);
 14861  15 
                     stream_OPEN_SQUARE_BRACKET.add(OPEN_SQUARE_BRACKET330);
 14862  15 
 
 14863   
 
 14864  15 
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3668);
 14865  15 
                     propertyListNotEmpty331=propertyListNotEmpty();
 14866   
 
 14867  30 
                     state._fsp--;
 14868  15 
 
 14869  15 
                     stream_propertyListNotEmpty.add(propertyListNotEmpty331.getTree());
 14870   
 
 14871  15 
                     CLOSE_SQUARE_BRACKET332=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3670);
 14872  30 
                     stream_CLOSE_SQUARE_BRACKET.add(CLOSE_SQUARE_BRACKET332);
 14873   
 
 14874  15 
 
 14875   
                     // AST REWRITE
 14876   
                     // elements: propertyListNotEmpty
 14877   
                     // token labels:
 14878   
                     // rule labels: retval
 14879   
                     // token list labels:
 14880  15 
                     // rule list labels:
 14881   
                     // wildcard labels:
 14882  15 
                     retval.tree = root_0;
 14883  15 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14884   
 
 14885  15 
                     root_0 = (Object)adaptor.nil();
 14886  29 
                     // 441:69: -> ^( TRIPLES_NODE propertyListNotEmpty )
 14887   
                     {
 14888   
                         // com\\googlecode\\sparkleg\\Sparql.g:441:72: ^( TRIPLES_NODE propertyListNotEmpty )
 14889  29 
                         {
 14890  44 
                         Object root_1 = (Object)adaptor.nil();
 14891  15 
                         root_1 = (Object)adaptor.becomeRoot(
 14892   
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 14893   
                         , root_1);
 14894   
 
 14895  15 
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 14896   
 
 14897  15 
                         adaptor.addChild(root_0, root_1);
 14898   
                         }
 14899   
 
 14900   
                     }
 14901   
 
 14902  29 
 
 14903  44 
                     retval.tree = root_0;
 14904   
 
 14905   
                     }
 14906   
                     break;
 14907   
 
 14908  1723 
             }
 14909  29 
             retval.stop = input.LT(-1);
 14910  1723 
 
 14911   
 
 14912  29 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14913  29 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14914   
 
 14915   
         }
 14916  0 
         catch (RecognitionException re) {
 14917  1723 
             reportError(re);
 14918  1723 
             recover(input,re);
 14919  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14920   
 
 14921  1723 
         }
 14922   
 
 14923  1723 
         finally {
 14924   
                 // do for sure before leaving
 14925  1752 
         }
 14926  29 
         return retval;
 14927   
     }
 14928   
     // $ANTLR end "triplesNode"
 14929   
 
 14930   
 
 14931  1723 
     public static class graphNode_return extends ParserRuleReturnScope {
 14932  1723 
         Object tree;
 14933  1723 
         public Object getTree() { return tree; }
 14934   
     };
 14935   
 
 14936   
 
 14937   
     // $ANTLR start "graphNode"
 14938   
     // com\\googlecode\\sparkleg\\Sparql.g:444:1: graphNode : ( varOrTerm | triplesNode );
 14939   
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 14940  1723 
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 14941  1723 
         retval.start = input.LT(1);
 14942   
 
 14943   
 
 14944  1723 
         Object root_0 = null;
 14945   
 
 14946  1723 
         SparqlParser.varOrTerm_return varOrTerm333 =null;
 14947   
 
 14948  1723 
         SparqlParser.triplesNode_return triplesNode334 =null;
 14949   
 
 14950   
 
 14951   
 
 14952   
         try {
 14953   
             // com\\googlecode\\sparkleg\\Sparql.g:445:5: ( varOrTerm | triplesNode )
 14954  1723 
             int alt113=2;
 14955  3402 
             switch ( input.LA(1) ) {
 14956   
             case BLANK_NODE_LABEL:
 14957  1679 
             case DECIMAL:
 14958   
             case DECIMAL_NEGATIVE:
 14959   
             case DECIMAL_POSITIVE:
 14960  22 
             case DOUBLE:
 14961   
             case DOUBLE_NEGATIVE:
 14962   
             case DOUBLE_POSITIVE:
 14963  12 
             case FALSE:
 14964   
             case INTEGER:
 14965  12 
             case INTEGER_NEGATIVE:
 14966   
             case INTEGER_POSITIVE:
 14967   
             case IRI_REF:
 14968   
             case PNAME_LN:
 14969   
             case PNAME_NS:
 14970   
             case STRING_LITERAL1:
 14971   
             case STRING_LITERAL2:
 14972   
             case STRING_LITERAL_LONG1:
 14973   
             case STRING_LITERAL_LONG2:
 14974   
             case TRUE:
 14975   
             case VAR1:
 14976  10 
             case VAR2:
 14977   
                 {
 14978  1689 
                 alt113=1;
 14979   
                 }
 14980  1679 
                 break;
 14981   
             case OPEN_SQUARE_BRACKET:
 14982   
                 {
 14983  22 
                 switch ( input.LA(2) ) {
 14984   
                 case CLOSE_SQUARE_BRACKET:
 14985   
                     {
 14986  12 
                     alt113=1;
 14987   
                     }
 14988  34 
                     break;
 14989   
                 case A:
 14990   
                 case INVERSE:
 14991  8 
                 case IRI_REF:
 14992   
                 case NEGATION:
 14993   
                 case OPEN_BRACE:
 14994  2 
                 case PNAME_LN:
 14995   
                 case PNAME_NS:
 14996  2 
                 case VAR1:
 14997   
                 case VAR2:
 14998   
                     {
 14999  10 
                     alt113=2;
 15000   
                     }
 15001  10 
                     break;
 15002   
                 default:
 15003  0 
                     NoViableAltException nvae =
 15004   
                         new NoViableAltException("", 113, 2, input);
 15005   
 
 15006  0 
                     throw nvae;
 15007   
 
 15008   
                 }
 15009   
 
 15010   
                 }
 15011  22 
                 break;
 15012   
             case OPEN_BRACE:
 15013   
                 {
 15014  8 
                 switch ( input.LA(2) ) {
 15015   
                 case CLOSE_BRACE:
 15016   
                     {
 15017  2 
                     alt113=1;
 15018   
                     }
 15019  2 
                     break;
 15020   
                 case BLANK_NODE_LABEL:
 15021  6 
                 case DECIMAL:
 15022   
                 case DECIMAL_NEGATIVE:
 15023  6 
                 case DECIMAL_POSITIVE:
 15024   
                 case DOUBLE:
 15025   
                 case DOUBLE_NEGATIVE:
 15026   
                 case DOUBLE_POSITIVE:
 15027   
                 case FALSE:
 15028   
                 case INTEGER:
 15029   
                 case INTEGER_NEGATIVE:
 15030   
                 case INTEGER_POSITIVE:
 15031   
                 case IRI_REF:
 15032   
                 case OPEN_BRACE:
 15033  8 
                 case OPEN_SQUARE_BRACKET:
 15034   
                 case PNAME_LN:
 15035  14 
                 case PNAME_NS:
 15036   
                 case STRING_LITERAL1:
 15037   
                 case STRING_LITERAL2:
 15038  14 
                 case STRING_LITERAL_LONG1:
 15039   
                 case STRING_LITERAL_LONG2:
 15040   
                 case TRUE:
 15041   
                 case VAR1:
 15042  1709 
                 case VAR2:
 15043   
                     {
 15044  6 
                     alt113=2;
 15045   
                     }
 15046  1699 
                     break;
 15047   
                 default:
 15048  0 
                     NoViableAltException nvae =
 15049  1693 
                         new NoViableAltException("", 113, 3, input);
 15050  1693 
 
 15051  0 
                     throw nvae;
 15052  1693 
 
 15053   
                 }
 15054  1693 
 
 15055   
                 }
 15056  8 
                 break;
 15057  1693 
             default:
 15058  14 
                 NoViableAltException nvae =
 15059   
                     new NoViableAltException("", 113, 0, input);
 15060   
 
 15061  30 
                 throw nvae;
 15062   
 
 15063   
             }
 15064  16 
 
 15065  1725 
             switch (alt113) {
 15066   
                 case 1 :
 15067  16 
                     // com\\googlecode\\sparkleg\\Sparql.g:445:7: varOrTerm
 15068   
                     {
 15069  1709 
                     root_0 = (Object)adaptor.nil();
 15070   
 
 15071   
 
 15072  1693 
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3695);
 15073  1693 
                     varOrTerm333=varOrTerm();
 15074   
 
 15075  3402 
                     state._fsp--;
 15076   
 
 15077  1693 
                     adaptor.addChild(root_0, varOrTerm333.getTree());
 15078  1709 
 
 15079  1709 
                     }
 15080  1693 
                     break;
 15081   
                 case 2 :
 15082  14 
                     // com\\googlecode\\sparkleg\\Sparql.g:445:19: triplesNode
 15083  14 
                     {
 15084  30 
                     root_0 = (Object)adaptor.nil();
 15085  14 
 
 15086   
 
 15087  16 
                     pushFollow(FOLLOW_triplesNode_in_graphNode3699);
 15088  16 
                     triplesNode334=triplesNode();
 15089   
 
 15090  16 
                     state._fsp--;
 15091  1723 
 
 15092  1739 
                     adaptor.addChild(root_0, triplesNode334.getTree());
 15093   
 
 15094   
                     }
 15095   
                     break;
 15096   
 
 15097  3257 
             }
 15098  1709 
             retval.stop = input.LT(-1);
 15099  3257 
 
 15100   
 
 15101  1709 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15102  1709 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15103   
 
 15104   
         }
 15105  14 
         catch (RecognitionException re) {
 15106  3271 
             reportError(re);
 15107  3271 
             recover(input,re);
 15108  14 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15109   
 
 15110  3257 
         }
 15111   
 
 15112  3257 
         finally {
 15113   
                 // do for sure before leaving
 15114  4980 
         }
 15115  1723 
         return retval;
 15116   
     }
 15117   
     // $ANTLR end "graphNode"
 15118   
 
 15119   
 
 15120  3257 
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15121  3257 
         Object tree;
 15122  3257 
         public Object getTree() { return tree; }
 15123   
     };
 15124   
 
 15125  2468 
 
 15126   
     // $ANTLR start "varOrTerm"
 15127  2468 
     // com\\googlecode\\sparkleg\\Sparql.g:448:1: varOrTerm : ( var | graphTerm );
 15128   
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15129  3257 
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15130  3257 
         retval.start = input.LT(1);
 15131   
 
 15132   
 
 15133  3257 
         Object root_0 = null;
 15134   
 
 15135  3257 
         SparqlParser.var_return var335 =null;
 15136   
 
 15137  3257 
         SparqlParser.graphTerm_return graphTerm336 =null;
 15138   
 
 15139   
 
 15140   
 
 15141   
         try {
 15142   
             // com\\googlecode\\sparkleg\\Sparql.g:449:5: ( var | graphTerm )
 15143  3257 
             int alt114=2;
 15144  3257 
             switch ( input.LA(1) ) {
 15145   
             case VAR1:
 15146   
             case VAR2:
 15147   
                 {
 15148  2468 
                 alt114=1;
 15149   
                 }
 15150  3257 
                 break;
 15151   
             case BLANK_NODE_LABEL:
 15152  789 
             case DECIMAL:
 15153   
             case DECIMAL_NEGATIVE:
 15154   
             case DECIMAL_POSITIVE:
 15155   
             case DOUBLE:
 15156   
             case DOUBLE_NEGATIVE:
 15157   
             case DOUBLE_POSITIVE:
 15158   
             case FALSE:
 15159   
             case INTEGER:
 15160   
             case INTEGER_NEGATIVE:
 15161  3257 
             case INTEGER_POSITIVE:
 15162   
             case IRI_REF:
 15163   
             case OPEN_BRACE:
 15164   
             case OPEN_SQUARE_BRACKET:
 15165  2468 
             case PNAME_LN:
 15166   
             case PNAME_NS:
 15167   
             case STRING_LITERAL1:
 15168  2468 
             case STRING_LITERAL2:
 15169  2468 
             case STRING_LITERAL_LONG1:
 15170   
             case STRING_LITERAL_LONG2:
 15171  2468 
             case TRUE:
 15172   
                 {
 15173  3257 
                 alt114=2;
 15174   
                 }
 15175  789 
                 break;
 15176  2468 
             default:
 15177  0 
                 NoViableAltException nvae =
 15178   
                     new NoViableAltException("", 114, 0, input);
 15179   
 
 15180  789 
                 throw nvae;
 15181   
 
 15182   
             }
 15183  789 
 
 15184  4046 
             switch (alt114) {
 15185   
                 case 1 :
 15186  789 
                     // com\\googlecode\\sparkleg\\Sparql.g:449:7: var
 15187   
                     {
 15188  3257 
                     root_0 = (Object)adaptor.nil();
 15189   
 
 15190   
 
 15191  2468 
                     pushFollow(FOLLOW_var_in_varOrTerm3716);
 15192  2468 
                     var335=var();
 15193   
 
 15194  5725 
                     state._fsp--;
 15195   
 
 15196  2468 
                     adaptor.addChild(root_0, var335.getTree());
 15197  3257 
 
 15198  3257 
                     }
 15199  2468 
                     break;
 15200   
                 case 2 :
 15201   
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: graphTerm
 15202   
                     {
 15203  789 
                     root_0 = (Object)adaptor.nil();
 15204   
 
 15205   
 
 15206  789 
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3724);
 15207  789 
                     graphTerm336=graphTerm();
 15208   
 
 15209  789 
                     state._fsp--;
 15210  3257 
 
 15211  4046 
                     adaptor.addChild(root_0, graphTerm336.getTree());
 15212   
 
 15213   
                     }
 15214   
                     break;
 15215   
 
 15216  129 
             }
 15217  3257 
             retval.stop = input.LT(-1);
 15218  150 
 
 15219   
 
 15220  3257 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15221  3257 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15222   
 
 15223   
         }
 15224  0 
         catch (RecognitionException re) {
 15225  129 
             reportError(re);
 15226  129 
             recover(input,re);
 15227  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15228   
 
 15229  129 
         }
 15230   
 
 15231  129 
         finally {
 15232   
                 // do for sure before leaving
 15233  3386 
         }
 15234  3257 
         return retval;
 15235   
     }
 15236   
     // $ANTLR end "varOrTerm"
 15237   
 
 15238   
 
 15239  129 
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15240  129 
         Object tree;
 15241  150 
         public Object getTree() { return tree; }
 15242   
     };
 15243   
 
 15244  73 
 
 15245   
     // $ANTLR start "varOrIRIref"
 15246  73 
     // com\\googlecode\\sparkleg\\Sparql.g:453:1: varOrIRIref : ( var | iriRef );
 15247   
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15248  129 
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15249  129 
         retval.start = input.LT(1);
 15250   
 
 15251  55 
 
 15252  129 
         Object root_0 = null;
 15253  55 
 
 15254  129 
         SparqlParser.var_return var337 =null;
 15255  1 
 
 15256  129 
         SparqlParser.iriRef_return iriRef338 =null;
 15257   
 
 15258  1 
 
 15259   
 
 15260   
         try {
 15261   
             // com\\googlecode\\sparkleg\\Sparql.g:454:5: ( var | iriRef )
 15262  257 
             int alt115=2;
 15263  129 
             switch ( input.LA(1) ) {
 15264   
             case VAR1:
 15265   
             case VAR2:
 15266  73 
                 {
 15267  73 
                 alt115=1;
 15268   
                 }
 15269  146 
                 break;
 15270  73 
             case IRI_REF:
 15271   
             case PNAME_LN:
 15272  73 
             case PNAME_NS:
 15273   
                 {
 15274  128 
                 alt115=2;
 15275   
                 }
 15276  55 
                 break;
 15277  73 
             default:
 15278  1 
                 NoViableAltException nvae =
 15279   
                     new NoViableAltException("", 115, 0, input);
 15280   
 
 15281  56 
                 throw nvae;
 15282   
 
 15283   
             }
 15284  55 
 
 15285  183 
             switch (alt115) {
 15286   
                 case 1 :
 15287  55 
                     // com\\googlecode\\sparkleg\\Sparql.g:454:7: var
 15288   
                     {
 15289  128 
                     root_0 = (Object)adaptor.nil();
 15290   
 
 15291   
 
 15292  73 
                     pushFollow(FOLLOW_var_in_varOrIRIref3741);
 15293  73 
                     var337=var();
 15294   
 
 15295  201 
                     state._fsp--;
 15296   
 
 15297  73 
                     adaptor.addChild(root_0, var337.getTree());
 15298  128 
 
 15299  128 
                     }
 15300  73 
                     break;
 15301   
                 case 2 :
 15302  1 
                     // com\\googlecode\\sparkleg\\Sparql.g:454:13: iriRef
 15303  1 
                     {
 15304  56 
                     root_0 = (Object)adaptor.nil();
 15305  1 
 
 15306   
 
 15307  55 
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref3745);
 15308  55 
                     iriRef338=iriRef();
 15309   
 
 15310  55 
                     state._fsp--;
 15311  129 
 
 15312  184 
                     adaptor.addChild(root_0, iriRef338.getTree());
 15313   
 
 15314   
                     }
 15315   
                     break;
 15316   
 
 15317  4467 
             }
 15318  128 
             retval.stop = input.LT(-1);
 15319  4467 
 
 15320   
 
 15321  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15322  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15323   
 
 15324   
         }
 15325  1 
         catch (RecognitionException re) {
 15326  4468 
             reportError(re);
 15327  4468 
             recover(input,re);
 15328  1 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15329   
 
 15330  4467 
         }
 15331   
 
 15332  4467 
         finally {
 15333   
                 // do for sure before leaving
 15334  4596 
         }
 15335  129 
         return retval;
 15336   
     }
 15337   
     // $ANTLR end "varOrIRIref"
 15338   
 
 15339   
 
 15340  4467 
     public static class var_return extends ParserRuleReturnScope {
 15341   
         Object tree;
 15342  4467 
         public Object getTree() { return tree; }
 15343  4467 
     };
 15344   
 
 15345  4467 
 
 15346  4467 
     // $ANTLR start "var"
 15347  4467 
     // com\\googlecode\\sparkleg\\Sparql.g:457:1: var : ( VAR1 | VAR2 );
 15348   
     public final SparqlParser.var_return var() throws RecognitionException {
 15349  4467 
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15350  8934 
         retval.start = input.LT(1);
 15351   
 
 15352   
 
 15353  4467 
         Object root_0 = null;
 15354   
 
 15355  4467 
         Token set339=null;
 15356   
 
 15357  4467 
         Object set339_tree=null;
 15358   
 
 15359   
         try {
 15360  4467 
             // com\\googlecode\\sparkleg\\Sparql.g:458:5: ( VAR1 | VAR2 )
 15361   
             // com\\googlecode\\sparkleg\\Sparql.g:
 15362   
             {
 15363  8934 
             root_0 = (Object)adaptor.nil();
 15364  4467 
 
 15365   
 
 15366  4467 
             set339=(Token)input.LT(1);
 15367   
 
 15368  4467 
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15369  4467 
                 input.consume();
 15370  4467 
                 adaptor.addChild(root_0,
 15371   
                 (Object)adaptor.create(set339)
 15372   
                 );
 15373  4467 
                 state.errorRecovery=false;
 15374   
             }
 15375   
             else {
 15376  4467 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15377  4467 
                 throw mse;
 15378   
             }
 15379   
 
 15380   
 
 15381   
             }
 15382  789 
 
 15383  4467 
             retval.stop = input.LT(-1);
 15384  789 
 
 15385   
 
 15386  4467 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15387  4467 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15388   
 
 15389   
         }
 15390  0 
         catch (RecognitionException re) {
 15391  789 
             reportError(re);
 15392  789 
             recover(input,re);
 15393  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15394   
 
 15395  789 
         }
 15396   
 
 15397  789 
         finally {
 15398   
                 // do for sure before leaving
 15399  5256 
         }
 15400  4467 
         return retval;
 15401  789 
     }
 15402   
     // $ANTLR end "var"
 15403  789 
 
 15404   
 
 15405  789 
     public static class graphTerm_return extends ParserRuleReturnScope {
 15406   
         Object tree;
 15407  789 
         public Object getTree() { return tree; }
 15408   
     };
 15409   
 
 15410   
 
 15411   
     // $ANTLR start "graphTerm"
 15412   
     // com\\googlecode\\sparkleg\\Sparql.g:461:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15413  789 
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15414  1578 
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15415  789 
         retval.start = input.LT(1);
 15416   
 
 15417   
 
 15418  789 
         Object root_0 = null;
 15419  552 
 
 15420  789 
         SparqlParser.iriRef_return iriRef340 =null;
 15421  552 
 
 15422  789 
         SparqlParser.rdfLiteral_return rdfLiteral341 =null;
 15423   
 
 15424  789 
         SparqlParser.numericLiteral_return numericLiteral342 =null;
 15425   
 
 15426  789 
         SparqlParser.booleanLiteral_return booleanLiteral343 =null;
 15427  78 
 
 15428  789 
         SparqlParser.blankNode_return blankNode344 =null;
 15429  78 
 
 15430  789 
         SparqlParser.nil_return nil345 =null;
 15431   
 
 15432   
 
 15433   
 
 15434   
         try {
 15435   
             // com\\googlecode\\sparkleg\\Sparql.g:462:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15436  789 
             int alt116=6;
 15437  789 
             switch ( input.LA(1) ) {
 15438   
             case IRI_REF:
 15439   
             case PNAME_LN:
 15440  48 
             case PNAME_NS:
 15441   
                 {
 15442  600 
                 alt116=1;
 15443   
                 }
 15444  552 
                 break;
 15445   
             case STRING_LITERAL1:
 15446  2 
             case STRING_LITERAL2:
 15447   
             case STRING_LITERAL_LONG1:
 15448  2 
             case STRING_LITERAL_LONG2:
 15449   
                 {
 15450  78 
                 alt116=2;
 15451   
                 }
 15452  180 
                 break;
 15453   
             case DECIMAL:
 15454  102 
             case DECIMAL_NEGATIVE:
 15455   
             case DECIMAL_POSITIVE:
 15456   
             case DOUBLE:
 15457  7 
             case DOUBLE_NEGATIVE:
 15458   
             case DOUBLE_POSITIVE:
 15459  7 
             case INTEGER:
 15460   
             case INTEGER_NEGATIVE:
 15461   
             case INTEGER_POSITIVE:
 15462   
                 {
 15463  48 
                 alt116=3;
 15464   
                 }
 15465  48 
                 break;
 15466   
             case FALSE:
 15467   
             case TRUE:
 15468  789 
                 {
 15469  2 
                 alt116=4;
 15470   
                 }
 15471  2 
                 break;
 15472  552 
             case BLANK_NODE_LABEL:
 15473   
             case OPEN_SQUARE_BRACKET:
 15474   
                 {
 15475  654 
                 alt116=5;
 15476  552 
                 }
 15477  102 
                 break;
 15478  552 
             case OPEN_BRACE:
 15479   
                 {
 15480  559 
                 alt116=6;
 15481   
                 }
 15482  7 
                 break;
 15483  552 
             default:
 15484  0 
                 NoViableAltException nvae =
 15485   
                     new NoViableAltException("", 116, 0, input);
 15486   
 
 15487  78 
                 throw nvae;
 15488   
 
 15489   
             }
 15490  78 
 
 15491  867 
             switch (alt116) {
 15492   
                 case 1 :
 15493  78 
                     // com\\googlecode\\sparkleg\\Sparql.g:462:7: iriRef
 15494   
                     {
 15495  630 
                     root_0 = (Object)adaptor.nil();
 15496   
 
 15497   
 
 15498  630 
                     pushFollow(FOLLOW_iriRef_in_graphTerm3783);
 15499  552 
                     iriRef340=iriRef();
 15500   
 
 15501  552 
                     state._fsp--;
 15502  48 
 
 15503  552 
                     adaptor.addChild(root_0, iriRef340.getTree());
 15504   
 
 15505  48 
                     }
 15506  600 
                     break;
 15507   
                 case 2 :
 15508  48 
                     // com\\googlecode\\sparkleg\\Sparql.g:463:7: rdfLiteral
 15509   
                     {
 15510  126 
                     root_0 = (Object)adaptor.nil();
 15511   
 
 15512   
 
 15513  126 
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm3791);
 15514  78 
                     rdfLiteral341=rdfLiteral();
 15515   
 
 15516  78 
                     state._fsp--;
 15517  2 
 
 15518  78 
                     adaptor.addChild(root_0, rdfLiteral341.getTree());
 15519   
 
 15520  2 
                     }
 15521  80 
                     break;
 15522   
                 case 3 :
 15523  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:464:7: numericLiteral
 15524   
                     {
 15525  50 
                     root_0 = (Object)adaptor.nil();
 15526   
 
 15527   
 
 15528  50 
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm3799);
 15529  48 
                     numericLiteral342=numericLiteral();
 15530   
 
 15531  48 
                     state._fsp--;
 15532  102 
 
 15533  48 
                     adaptor.addChild(root_0, numericLiteral342.getTree());
 15534   
 
 15535  102 
                     }
 15536  150 
                     break;
 15537   
                 case 4 :
 15538  102 
                     // com\\googlecode\\sparkleg\\Sparql.g:465:7: booleanLiteral
 15539   
                     {
 15540  104 
                     root_0 = (Object)adaptor.nil();
 15541   
 
 15542   
 
 15543  104 
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm3807);
 15544  2 
                     booleanLiteral343=booleanLiteral();
 15545   
 
 15546  2 
                     state._fsp--;
 15547  7 
 
 15548  2 
                     adaptor.addChild(root_0, booleanLiteral343.getTree());
 15549   
 
 15550  7 
                     }
 15551  9 
                     break;
 15552   
                 case 5 :
 15553  7 
                     // com\\googlecode\\sparkleg\\Sparql.g:466:7: blankNode
 15554   
                     {
 15555  109 
                     root_0 = (Object)adaptor.nil();
 15556   
 
 15557   
 
 15558  102 
                     pushFollow(FOLLOW_blankNode_in_graphTerm3815);
 15559  102 
                     blankNode344=blankNode();
 15560   
 
 15561  891 
                     state._fsp--;
 15562   
 
 15563  102 
                     adaptor.addChild(root_0, blankNode344.getTree());
 15564  789 
 
 15565  789 
                     }
 15566  102 
                     break;
 15567   
                 case 6 :
 15568   
                     // com\\googlecode\\sparkleg\\Sparql.g:467:7: nil
 15569   
                     {
 15570  7 
                     root_0 = (Object)adaptor.nil();
 15571   
 
 15572   
 
 15573  7 
                     pushFollow(FOLLOW_nil_in_graphTerm3823);
 15574  7 
                     nil345=nil();
 15575   
 
 15576  7 
                     state._fsp--;
 15577  789 
 
 15578  796 
                     adaptor.addChild(root_0, nil345.getTree());
 15579   
 
 15580   
                     }
 15581   
                     break;
 15582   
 
 15583  15 
             }
 15584  789 
             retval.stop = input.LT(-1);
 15585  15 
 
 15586   
 
 15587  789 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15588  789 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15589   
 
 15590   
         }
 15591  0 
         catch (RecognitionException re) {
 15592  15 
             reportError(re);
 15593  15 
             recover(input,re);
 15594  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15595   
 
 15596  15 
         }
 15597   
 
 15598  15 
         finally {
 15599  15 
                 // do for sure before leaving
 15600  789 
         }
 15601  804 
         return retval;
 15602  15 
     }
 15603   
     // $ANTLR end "graphTerm"
 15604   
 
 15605   
 
 15606  15 
     public static class nil_return extends ParserRuleReturnScope {
 15607   
         Object tree;
 15608  15 
         public Object getTree() { return tree; }
 15609   
     };
 15610   
 
 15611  15 
 
 15612  15 
     // $ANTLR start "nil"
 15613   
     // com\\googlecode\\sparkleg\\Sparql.g:470:1: nil : OPEN_BRACE CLOSE_BRACE ;
 15614   
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15615  30 
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15616  15 
         retval.start = input.LT(1);
 15617   
 
 15618  15 
 
 15619  30 
         Object root_0 = null;
 15620   
 
 15621  15 
         Token OPEN_BRACE346=null;
 15622  30 
         Token CLOSE_BRACE347=null;
 15623   
 
 15624  15 
         Object OPEN_BRACE346_tree=null;
 15625  15 
         Object CLOSE_BRACE347_tree=null;
 15626   
 
 15627  15 
         try {
 15628   
             // com\\googlecode\\sparkleg\\Sparql.g:471:5: ( OPEN_BRACE CLOSE_BRACE )
 15629   
             // com\\googlecode\\sparkleg\\Sparql.g:471:7: OPEN_BRACE CLOSE_BRACE
 15630  15 
             {
 15631  30 
             root_0 = (Object)adaptor.nil();
 15632   
 
 15633   
 
 15634  15 
             OPEN_BRACE346=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_nil3844);
 15635  15 
             OPEN_BRACE346_tree =
 15636   
             (Object)adaptor.create(OPEN_BRACE346)
 15637   
             ;
 15638  15 
             adaptor.addChild(root_0, OPEN_BRACE346_tree);
 15639   
 
 15640   
 
 15641  15 
             CLOSE_BRACE347=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_nil3846);
 15642  15 
             CLOSE_BRACE347_tree =
 15643  15 
             (Object)adaptor.create(CLOSE_BRACE347)
 15644  15 
             ;
 15645  15 
             adaptor.addChild(root_0, CLOSE_BRACE347_tree);
 15646   
 
 15647   
 
 15648   
             }
 15649  826 
 
 15650  15 
             retval.stop = input.LT(-1);
 15651  826 
 
 15652   
 
 15653  15 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15654  15 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15655   
 
 15656   
         }
 15657  0 
         catch (RecognitionException re) {
 15658  826 
             reportError(re);
 15659  826 
             recover(input,re);
 15660  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15661   
 
 15662  826 
         }
 15663   
 
 15664  826 
         finally {
 15665   
                 // do for sure before leaving
 15666  15 
         }
 15667  15 
         return retval;
 15668   
     }
 15669   
     // $ANTLR end "nil"
 15670   
 
 15671   
 
 15672  826 
     public static class expression_return extends ParserRuleReturnScope {
 15673   
         Object tree;
 15674  826 
         public Object getTree() { return tree; }
 15675  826 
     };
 15676  826 
 
 15677   
 
 15678  826 
     // $ANTLR start "expression"
 15679   
     // com\\googlecode\\sparkleg\\Sparql.g:474:1: expression : conditionalOrExpression ;
 15680  826 
     public final SparqlParser.expression_return expression() throws RecognitionException {
 15681  826 
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 15682  826 
         retval.start = input.LT(1);
 15683   
 
 15684  826 
 
 15685  826 
         Object root_0 = null;
 15686   
 
 15687  1652 
         SparqlParser.conditionalOrExpression_return conditionalOrExpression348 =null;
 15688  826 
 
 15689   
 
 15690   
 
 15691   
         try {
 15692   
             // com\\googlecode\\sparkleg\\Sparql.g:475:5: ( conditionalOrExpression )
 15693   
             // com\\googlecode\\sparkleg\\Sparql.g:475:7: conditionalOrExpression
 15694   
             {
 15695  826 
             root_0 = (Object)adaptor.nil();
 15696   
 
 15697   
 
 15698  826 
             pushFollow(FOLLOW_conditionalOrExpression_in_expression3863);
 15699  826 
             conditionalOrExpression348=conditionalOrExpression();
 15700  826 
 
 15701  1652 
             state._fsp--;
 15702   
 
 15703  826 
             adaptor.addChild(root_0, conditionalOrExpression348.getTree());
 15704   
 
 15705   
             }
 15706  826 
 
 15707  826 
             retval.stop = input.LT(-1);
 15708  826 
 
 15709   
 
 15710  826 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15711  826 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15712   
 
 15713   
         }
 15714  0 
         catch (RecognitionException re) {
 15715  826 
             reportError(re);
 15716  826 
             recover(input,re);
 15717  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15718   
 
 15719  826 
         }
 15720   
 
 15721  826 
         finally {
 15722  826 
                 // do for sure before leaving
 15723  826 
         }
 15724  1652 
         return retval;
 15725   
     }
 15726   
     // $ANTLR end "expression"
 15727  826 
 
 15728  826 
 
 15729  826 
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 15730   
         Object tree;
 15731  826 
         public Object getTree() { return tree; }
 15732   
     };
 15733   
 
 15734   
 
 15735   
     // $ANTLR start "conditionalOrExpression"
 15736   
     // com\\googlecode\\sparkleg\\Sparql.g:478:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* ;
 15737  826 
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 15738  1652 
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 15739  826 
         retval.start = input.LT(1);
 15740  826 
 
 15741   
 
 15742  1652 
         Object root_0 = null;
 15743   
 
 15744  826 
         Token OR349=null;
 15745  826 
         SparqlParser.conditionalAndExpression_return c1 =null;
 15746   
 
 15747  826 
         SparqlParser.conditionalAndExpression_return c2 =null;
 15748   
 
 15749   
 
 15750  826 
         Object OR349_tree=null;
 15751  1652 
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 15752  1652 
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 15753  826 
         try {
 15754   
             // com\\googlecode\\sparkleg\\Sparql.g:479:5: ( (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* )
 15755  826 
             // com\\googlecode\\sparkleg\\Sparql.g:479:7: (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15756   
             {
 15757   
             // com\\googlecode\\sparkleg\\Sparql.g:479:7: (c1= conditionalAndExpression -> $c1)
 15758  826 
             // com\\googlecode\\sparkleg\\Sparql.g:479:8: c1= conditionalAndExpression
 15759   
             {
 15760  826 
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3883);
 15761  826 
             c1=conditionalAndExpression();
 15762   
 
 15763  1652 
             state._fsp--;
 15764   
 
 15765  826 
             stream_conditionalAndExpression.add(c1.getTree());
 15766   
 
 15767   
             // AST REWRITE
 15768   
             // elements: c1
 15769   
             // token labels:
 15770   
             // rule labels: retval, c1
 15771  850 
             // token list labels:
 15772  850 
             // rule list labels:
 15773   
             // wildcard labels:
 15774  826 
             retval.tree = root_0;
 15775  850 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15776  826 
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 15777   
 
 15778  826 
             root_0 = (Object)adaptor.nil();
 15779   
             // 479:36: -> $c1
 15780   
             {
 15781  1676 
                 adaptor.addChild(root_0, stream_c1.nextTree());
 15782   
 
 15783   
             }
 15784   
 
 15785  24 
 
 15786  850 
             retval.tree = root_0;
 15787   
 
 15788   
             }
 15789  24 
 
 15790  24 
 
 15791   
             // com\\googlecode\\sparkleg\\Sparql.g:479:44: ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15792  24 
             loop117:
 15793   
             do {
 15794  874 
                 int alt117=2;
 15795  850 
                 switch ( input.LA(1) ) {
 15796   
                 case OR:
 15797   
                     {
 15798  24 
                     alt117=1;
 15799   
                     }
 15800   
                     break;
 15801   
 
 15802   
                 }
 15803  24 
 
 15804  874 
                 switch (alt117) {
 15805  24 
                     case 1 :
 15806   
                         // com\\googlecode\\sparkleg\\Sparql.g:479:45: OR c2= conditionalAndExpression
 15807  24 
                         {
 15808  24 
                         OR349=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression3892);
 15809  24 
                         stream_OR.add(OR349);
 15810   
 
 15811   
 
 15812  48 
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3896);
 15813  48 
                         c2=conditionalAndExpression();
 15814   
 
 15815  24 
                         state._fsp--;
 15816   
 
 15817  48 
                         stream_conditionalAndExpression.add(c2.getTree());
 15818   
 
 15819  24 
                         // AST REWRITE
 15820   
                         // elements: c2, OR, conditionalOrExpression
 15821  24 
                         // token labels:
 15822   
                         // rule labels: retval, c2
 15823   
                         // token list labels:
 15824   
                         // rule list labels:
 15825   
                         // wildcard labels:
 15826  24 
                         retval.tree = root_0;
 15827  48 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15828  24 
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 15829   
 
 15830  48 
                         root_0 = (Object)adaptor.nil();
 15831   
                         // 479:76: -> ^( OR $conditionalOrExpression $c2)
 15832   
                         {
 15833  826 
                             // com\\googlecode\\sparkleg\\Sparql.g:479:79: ^( OR $conditionalOrExpression $c2)
 15834   
                             {
 15835  48 
                             Object root_1 = (Object)adaptor.nil();
 15836  24 
                             root_1 = (Object)adaptor.becomeRoot(
 15837   
                             stream_OR.nextNode()
 15838   
                             , root_1);
 15839   
 
 15840  850 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15841   
 
 15842  24 
                             adaptor.addChild(root_1, stream_c2.nextTree());
 15843  826 
 
 15844  850 
                             adaptor.addChild(root_0, root_1);
 15845   
                             }
 15846   
 
 15847   
                         }
 15848   
 
 15849   
 
 15850  24 
                         retval.tree = root_0;
 15851   
 
 15852   
                         }
 15853  24 
                         break;
 15854   
 
 15855   
                     default :
 15856  1652 
                         break loop117;
 15857  826 
                 }
 15858  24 
             } while (true);
 15859   
 
 15860   
 
 15861   
             }
 15862  850 
 
 15863  826 
             retval.stop = input.LT(-1);
 15864  850 
 
 15865   
 
 15866  826 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15867  826 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15868   
 
 15869   
         }
 15870  0 
         catch (RecognitionException re) {
 15871  850 
             reportError(re);
 15872  850 
             recover(input,re);
 15873  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15874   
 
 15875  850 
         }
 15876   
 
 15877  850 
         finally {
 15878  850 
                 // do for sure before leaving
 15879  826 
         }
 15880  1676 
         return retval;
 15881   
     }
 15882   
     // $ANTLR end "conditionalOrExpression"
 15883  850 
 
 15884  850 
 
 15885  850 
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 15886   
         Object tree;
 15887  850 
         public Object getTree() { return tree; }
 15888   
     };
 15889   
 
 15890   
 
 15891   
     // $ANTLR start "conditionalAndExpression"
 15892   
     // com\\googlecode\\sparkleg\\Sparql.g:482:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* ;
 15893  850 
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 15894  1700 
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 15895  850 
         retval.start = input.LT(1);
 15896  850 
 
 15897   
 
 15898  1700 
         Object root_0 = null;
 15899   
 
 15900  850 
         Token AND350=null;
 15901  850 
         SparqlParser.valueLogical_return v1 =null;
 15902   
 
 15903  850 
         SparqlParser.valueLogical_return v2 =null;
 15904   
 
 15905   
 
 15906  850 
         Object AND350_tree=null;
 15907  1700 
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 15908  1700 
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 15909  850 
         try {
 15910   
             // com\\googlecode\\sparkleg\\Sparql.g:483:5: ( (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* )
 15911  850 
             // com\\googlecode\\sparkleg\\Sparql.g:483:7: (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 15912   
             {
 15913   
             // com\\googlecode\\sparkleg\\Sparql.g:483:7: (v1= valueLogical -> $v1)
 15914  850 
             // com\\googlecode\\sparkleg\\Sparql.g:483:8: v1= valueLogical
 15915   
             {
 15916  850 
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3930);
 15917  850 
             v1=valueLogical();
 15918   
 
 15919  1700 
             state._fsp--;
 15920   
 
 15921  850 
             stream_valueLogical.add(v1.getTree());
 15922   
 
 15923   
             // AST REWRITE
 15924   
             // elements: v1
 15925   
             // token labels:
 15926   
             // rule labels: v1, retval
 15927  874 
             // token list labels:
 15928  874 
             // rule list labels:
 15929   
             // wildcard labels:
 15930  850 
             retval.tree = root_0;
 15931  874 
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 15932  850 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15933   
 
 15934  850 
             root_0 = (Object)adaptor.nil();
 15935   
             // 483:24: -> $v1
 15936   
             {
 15937  1724 
                 adaptor.addChild(root_0, stream_v1.nextTree());
 15938   
 
 15939   
             }
 15940   
 
 15941  24 
 
 15942  874 
             retval.tree = root_0;
 15943   
 
 15944   
             }
 15945  24 
 
 15946  24 
 
 15947   
             // com\\googlecode\\sparkleg\\Sparql.g:483:32: ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 15948  24 
             loop118:
 15949   
             do {
 15950  898 
                 int alt118=2;
 15951  874 
                 switch ( input.LA(1) ) {
 15952   
                 case AND:
 15953   
                     {
 15954  24 
                     alt118=1;
 15955   
                     }
 15956   
                     break;
 15957   
 
 15958   
                 }
 15959  24 
 
 15960  898 
                 switch (alt118) {
 15961  24 
                     case 1 :
 15962   
                         // com\\googlecode\\sparkleg\\Sparql.g:483:33: AND v2= valueLogical
 15963  24 
                         {
 15964  24 
                         AND350=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression3939);
 15965  24 
                         stream_AND.add(AND350);
 15966   
 
 15967   
 
 15968  48 
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3943);
 15969  48 
                         v2=valueLogical();
 15970   
 
 15971  24 
                         state._fsp--;
 15972   
 
 15973  48 
                         stream_valueLogical.add(v2.getTree());
 15974   
 
 15975  24 
                         // AST REWRITE
 15976   
                         // elements: AND, v2, conditionalAndExpression
 15977  24 
                         // token labels:
 15978   
                         // rule labels: retval, v2
 15979   
                         // token list labels:
 15980   
                         // rule list labels:
 15981   
                         // wildcard labels:
 15982  24 
                         retval.tree = root_0;
 15983  48 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15984  24 
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 15985   
 
 15986  48 
                         root_0 = (Object)adaptor.nil();
 15987   
                         // 483:53: -> ^( AND $conditionalAndExpression $v2)
 15988   
                         {
 15989  850 
                             // com\\googlecode\\sparkleg\\Sparql.g:483:56: ^( AND $conditionalAndExpression $v2)
 15990   
                             {
 15991  48 
                             Object root_1 = (Object)adaptor.nil();
 15992  24 
                             root_1 = (Object)adaptor.becomeRoot(
 15993   
                             stream_AND.nextNode()
 15994   
                             , root_1);
 15995   
 
 15996  874 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15997   
 
 15998  24 
                             adaptor.addChild(root_1, stream_v2.nextTree());
 15999  850 
 
 16000  874 
                             adaptor.addChild(root_0, root_1);
 16001   
                             }
 16002   
 
 16003   
                         }
 16004   
 
 16005   
 
 16006  24 
                         retval.tree = root_0;
 16007   
 
 16008   
                         }
 16009  24 
                         break;
 16010   
 
 16011   
                     default :
 16012  1700 
                         break loop118;
 16013  850 
                 }
 16014  24 
             } while (true);
 16015   
 
 16016   
 
 16017   
             }
 16018  874 
 
 16019  850 
             retval.stop = input.LT(-1);
 16020  874 
 
 16021   
 
 16022  850 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16023  850 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16024   
 
 16025   
         }
 16026  0 
         catch (RecognitionException re) {
 16027  874 
             reportError(re);
 16028  874 
             recover(input,re);
 16029  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16030   
 
 16031  874 
         }
 16032   
 
 16033  874 
         finally {
 16034   
                 // do for sure before leaving
 16035  850 
         }
 16036  850 
         return retval;
 16037   
     }
 16038   
     // $ANTLR end "conditionalAndExpression"
 16039   
 
 16040   
 
 16041  874 
     public static class valueLogical_return extends ParserRuleReturnScope {
 16042   
         Object tree;
 16043  874 
         public Object getTree() { return tree; }
 16044  874 
     };
 16045  874 
 
 16046   
 
 16047  874 
     // $ANTLR start "valueLogical"
 16048   
     // com\\googlecode\\sparkleg\\Sparql.g:486:1: valueLogical : relationalExpression ;
 16049  874 
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16050  874 
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16051  874 
         retval.start = input.LT(1);
 16052   
 
 16053  874 
 
 16054  874 
         Object root_0 = null;
 16055   
 
 16056  1748 
         SparqlParser.relationalExpression_return relationalExpression351 =null;
 16057  874 
 
 16058   
 
 16059   
 
 16060   
         try {
 16061   
             // com\\googlecode\\sparkleg\\Sparql.g:487:5: ( relationalExpression )
 16062   
             // com\\googlecode\\sparkleg\\Sparql.g:487:7: relationalExpression
 16063   
             {
 16064  874 
             root_0 = (Object)adaptor.nil();
 16065   
 
 16066   
 
 16067  874 
             pushFollow(FOLLOW_relationalExpression_in_valueLogical3974);
 16068  874 
             relationalExpression351=relationalExpression();
 16069  874 
 
 16070  1748 
             state._fsp--;
 16071   
 
 16072  874 
             adaptor.addChild(root_0, relationalExpression351.getTree());
 16073   
 
 16074   
             }
 16075  874 
 
 16076  874 
             retval.stop = input.LT(-1);
 16077  874 
 
 16078   
 
 16079  874 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16080  874 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16081   
 
 16082   
         }
 16083  0 
         catch (RecognitionException re) {
 16084  874 
             reportError(re);
 16085  874 
             recover(input,re);
 16086  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16087   
 
 16088  874 
         }
 16089   
 
 16090  874 
         finally {
 16091  874 
                 // do for sure before leaving
 16092  1748 
         }
 16093  1748 
         return retval;
 16094  874 
     }
 16095  874 
     // $ANTLR end "valueLogical"
 16096  874 
 
 16097  874 
 
 16098  874 
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16099  874 
         Object tree;
 16100  874 
         public Object getTree() { return tree; }
 16101  874 
     };
 16102   
 
 16103  874 
 
 16104   
     // $ANTLR start "relationalExpression"
 16105  874 
     // com\\googlecode\\sparkleg\\Sparql.g:490:1: relationalExpression : (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16106   
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16107  1748 
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16108  874 
         retval.start = input.LT(1);
 16109  874 
 
 16110   
 
 16111  1748 
         Object root_0 = null;
 16112   
 
 16113  1748 
         Token EQUAL352=null;
 16114  874 
         Token NOT_EQUAL353=null;
 16115  1748 
         Token LESS354=null;
 16116  874 
         Token GREATER355=null;
 16117  874 
         Token LESS_EQUAL356=null;
 16118  1748 
         Token GREATER_EQUAL357=null;
 16119  1748 
         Token IN358=null;
 16120  1748 
         Token NOT359=null;
 16121  1748 
         Token IN360=null;
 16122  1748 
         SparqlParser.numericExpression_return n1 =null;
 16123  874 
 
 16124  1748 
         SparqlParser.numericExpression_return n2 =null;
 16125  874 
 
 16126  1748 
         SparqlParser.numericExpression_return n3 =null;
 16127  874 
 
 16128  1748 
         SparqlParser.numericExpression_return n4 =null;
 16129  874 
 
 16130  1748 
         SparqlParser.numericExpression_return n5 =null;
 16131  874 
 
 16132  1748 
         SparqlParser.numericExpression_return n6 =null;
 16133  874 
 
 16134  1748 
         SparqlParser.numericExpression_return n7 =null;
 16135  874 
 
 16136  1748 
         SparqlParser.expressionList_return l2 =null;
 16137   
 
 16138  874 
         SparqlParser.expressionList_return l3 =null;
 16139   
 
 16140   
 
 16141  874 
         Object EQUAL352_tree=null;
 16142  874 
         Object NOT_EQUAL353_tree=null;
 16143  874 
         Object LESS354_tree=null;
 16144  1748 
         Object GREATER355_tree=null;
 16145  1748 
         Object LESS_EQUAL356_tree=null;
 16146  874 
         Object GREATER_EQUAL357_tree=null;
 16147  1748 
         Object IN358_tree=null;
 16148  874 
         Object NOT359_tree=null;
 16149  1748 
         Object IN360_tree=null;
 16150  874 
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16151  874 
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16152  874 
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16153  874 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16154  874 
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16155  874 
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16156  874 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16157  874 
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16158  1748 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16159  1748 
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16160  874 
         try {
 16161   
             // com\\googlecode\\sparkleg\\Sparql.g:491:5: ( (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16162  874 
             // com\\googlecode\\sparkleg\\Sparql.g:491:7: (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16163   
             {
 16164   
             // com\\googlecode\\sparkleg\\Sparql.g:491:7: (n1= numericExpression -> $n1)
 16165  874 
             // com\\googlecode\\sparkleg\\Sparql.g:491:8: n1= numericExpression
 16166   
             {
 16167  874 
             pushFollow(FOLLOW_numericExpression_in_relationalExpression3994);
 16168  874 
             n1=numericExpression();
 16169   
 
 16170  1748 
             state._fsp--;
 16171   
 
 16172  874 
             stream_numericExpression.add(n1.getTree());
 16173   
 
 16174   
             // AST REWRITE
 16175   
             // elements: n1
 16176  874 
             // token labels:
 16177  874 
             // rule labels: n1, retval
 16178   
             // token list labels:
 16179   
             // rule list labels:
 16180  138 
             // wildcard labels:
 16181  874 
             retval.tree = root_0;
 16182  1012 
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16183  874 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16184   
 
 16185  902 
             root_0 = (Object)adaptor.nil();
 16186   
             // 491:29: -> $n1
 16187  28 
             {
 16188  874 
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16189   
 
 16190  18 
             }
 16191   
 
 16192  18 
 
 16193  874 
             retval.tree = root_0;
 16194   
 
 16195  18 
             }
 16196   
 
 16197  18 
 
 16198   
             // com\\googlecode\\sparkleg\\Sparql.g:491:37: ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16199  874 
             int alt119=9;
 16200  876 
             switch ( input.LA(1) ) {
 16201   
                 case EQUAL:
 16202  2 
                     {
 16203  138 
                     alt119=1;
 16204   
                     }
 16205  141 
                     break;
 16206   
                 case NOT_EQUAL:
 16207  3 
                     {
 16208  28 
                     alt119=2;
 16209   
                     }
 16210  30 
                     break;
 16211   
                 case LESS:
 16212  2 
                     {
 16213  18 
                     alt119=3;
 16214   
                     }
 16215  20 
                     break;
 16216   
                 case GREATER:
 16217   
                     {
 16218  18 
                     alt119=4;
 16219   
                     }
 16220  892 
                     break;
 16221   
                 case LESS_EQUAL:
 16222   
                     {
 16223  2 
                     alt119=5;
 16224   
                     }
 16225  2 
                     break;
 16226   
                 case GREATER_EQUAL:
 16227  138 
                     {
 16228  141 
                     alt119=6;
 16229   
                     }
 16230  3 
                     break;
 16231  138 
                 case IN:
 16232  138 
                     {
 16233  2 
                     alt119=7;
 16234  138 
                     }
 16235  2 
                     break;
 16236  138 
                 case NOT:
 16237   
                     {
 16238  2 
                     alt119=8;
 16239   
                     }
 16240   
                     break;
 16241   
             }
 16242   
 
 16243  874 
             switch (alt119) {
 16244   
                 case 1 :
 16245  138 
                     // com\\googlecode\\sparkleg\\Sparql.g:491:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16246  138 
                     {
 16247  138 
                     // com\\googlecode\\sparkleg\\Sparql.g:491:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16248   
                     // com\\googlecode\\sparkleg\\Sparql.g:491:39: EQUAL n2= numericExpression
 16249  138 
                     {
 16250  138 
                     EQUAL352=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4004);
 16251  138 
                     stream_EQUAL.add(EQUAL352);
 16252   
 
 16253   
 
 16254  276 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4008);
 16255  276 
                     n2=numericExpression();
 16256   
 
 16257  138 
                     state._fsp--;
 16258   
 
 16259  276 
                     stream_numericExpression.add(n2.getTree());
 16260   
 
 16261  138 
                     // AST REWRITE
 16262   
                     // elements: relationalExpression, EQUAL, n2
 16263  138 
                     // token labels:
 16264   
                     // rule labels: retval, n2
 16265   
                     // token list labels:
 16266   
                     // rule list labels:
 16267   
                     // wildcard labels:
 16268  138 
                     retval.tree = root_0;
 16269  276 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16270  138 
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16271   
 
 16272  138 
                     root_0 = (Object)adaptor.nil();
 16273   
                     // 491:66: -> ^( EQUAL $relationalExpression $n2)
 16274   
                     {
 16275  138 
                         // com\\googlecode\\sparkleg\\Sparql.g:491:69: ^( EQUAL $relationalExpression $n2)
 16276   
                         {
 16277  138 
                         Object root_1 = (Object)adaptor.nil();
 16278  138 
                         root_1 = (Object)adaptor.becomeRoot(
 16279   
                         stream_EQUAL.nextNode()
 16280   
                         , root_1);
 16281   
 
 16282  166 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16283  28 
 
 16284  138 
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16285   
 
 16286  166 
                         adaptor.addChild(root_0, root_1);
 16287  28 
                         }
 16288   
 
 16289  28 
                     }
 16290   
 
 16291  28 
 
 16292  138 
                     retval.tree = root_0;
 16293   
 
 16294   
                     }
 16295   
 
 16296   
 
 16297   
                     }
 16298  138 
                     break;
 16299   
                 case 2 :
 16300  28 
                     // com\\googlecode\\sparkleg\\Sparql.g:492:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16301  28 
                     {
 16302  28 
                     // com\\googlecode\\sparkleg\\Sparql.g:492:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16303   
                     // com\\googlecode\\sparkleg\\Sparql.g:492:40: NOT_EQUAL n3= numericExpression
 16304  28 
                     {
 16305  28 
                     NOT_EQUAL353=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4065);
 16306  28 
                     stream_NOT_EQUAL.add(NOT_EQUAL353);
 16307   
 
 16308   
 
 16309  56 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4069);
 16310  56 
                     n3=numericExpression();
 16311   
 
 16312  28 
                     state._fsp--;
 16313   
 
 16314  56 
                     stream_numericExpression.add(n3.getTree());
 16315   
 
 16316  28 
                     // AST REWRITE
 16317   
                     // elements: relationalExpression, n3, NOT_EQUAL
 16318  28 
                     // token labels:
 16319   
                     // rule labels: retval, n3
 16320   
                     // token list labels:
 16321   
                     // rule list labels:
 16322   
                     // wildcard labels:
 16323  28 
                     retval.tree = root_0;
 16324  56 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16325  28 
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16326   
 
 16327  28 
                     root_0 = (Object)adaptor.nil();
 16328   
                     // 492:71: -> ^( NOT_EQUAL $relationalExpression $n3)
 16329   
                     {
 16330  28 
                         // com\\googlecode\\sparkleg\\Sparql.g:492:74: ^( NOT_EQUAL $relationalExpression $n3)
 16331   
                         {
 16332  28 
                         Object root_1 = (Object)adaptor.nil();
 16333  28 
                         root_1 = (Object)adaptor.becomeRoot(
 16334   
                         stream_NOT_EQUAL.nextNode()
 16335   
                         , root_1);
 16336   
 
 16337  46 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16338  18 
 
 16339  28 
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16340   
 
 16341  46 
                         adaptor.addChild(root_0, root_1);
 16342  18 
                         }
 16343   
 
 16344  18 
                     }
 16345   
 
 16346  18 
 
 16347  28 
                     retval.tree = root_0;
 16348   
 
 16349   
                     }
 16350   
 
 16351   
 
 16352   
                     }
 16353  28 
                     break;
 16354   
                 case 3 :
 16355  18 
                     // com\\googlecode\\sparkleg\\Sparql.g:493:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16356  18 
                     {
 16357  18 
                     // com\\googlecode\\sparkleg\\Sparql.g:493:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16358   
                     // com\\googlecode\\sparkleg\\Sparql.g:493:40: LESS n4= numericExpression
 16359  18 
                     {
 16360  18 
                     LESS354=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4124);
 16361  18 
                     stream_LESS.add(LESS354);
 16362   
 
 16363   
 
 16364  36 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4128);
 16365  36 
                     n4=numericExpression();
 16366   
 
 16367  18 
                     state._fsp--;
 16368   
 
 16369  36 
                     stream_numericExpression.add(n4.getTree());
 16370   
 
 16371  18 
                     // AST REWRITE
 16372   
                     // elements: n4, LESS, relationalExpression
 16373  18 
                     // token labels:
 16374   
                     // rule labels: retval, n4
 16375   
                     // token list labels:
 16376   
                     // rule list labels:
 16377   
                     // wildcard labels:
 16378  18 
                     retval.tree = root_0;
 16379  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16380  18 
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16381   
 
 16382  18 
                     root_0 = (Object)adaptor.nil();
 16383   
                     // 493:66: -> ^( LESS $relationalExpression $n4)
 16384   
                     {
 16385  18 
                         // com\\googlecode\\sparkleg\\Sparql.g:493:69: ^( LESS $relationalExpression $n4)
 16386   
                         {
 16387  18 
                         Object root_1 = (Object)adaptor.nil();
 16388  18 
                         root_1 = (Object)adaptor.becomeRoot(
 16389   
                         stream_LESS.nextNode()
 16390   
                         , root_1);
 16391   
 
 16392  36 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16393  18 
 
 16394  18 
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16395   
 
 16396  36 
                         adaptor.addChild(root_0, root_1);
 16397  18 
                         }
 16398   
 
 16399  18 
                     }
 16400   
 
 16401  18 
 
 16402  18 
                     retval.tree = root_0;
 16403   
 
 16404   
                     }
 16405   
 
 16406   
 
 16407   
                     }
 16408  18 
                     break;
 16409   
                 case 4 :
 16410  18 
                     // com\\googlecode\\sparkleg\\Sparql.g:494:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16411  18 
                     {
 16412  18 
                     // com\\googlecode\\sparkleg\\Sparql.g:494:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16413   
                     // com\\googlecode\\sparkleg\\Sparql.g:494:40: GREATER n5= numericExpression
 16414  18 
                     {
 16415  18 
                     GREATER355=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4183);
 16416  18 
                     stream_GREATER.add(GREATER355);
 16417   
 
 16418   
 
 16419  36 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4187);
 16420  36 
                     n5=numericExpression();
 16421   
 
 16422  18 
                     state._fsp--;
 16423   
 
 16424  36 
                     stream_numericExpression.add(n5.getTree());
 16425   
 
 16426  18 
                     // AST REWRITE
 16427   
                     // elements: relationalExpression, GREATER, n5
 16428  18 
                     // token labels:
 16429   
                     // rule labels: retval, n5
 16430   
                     // token list labels:
 16431   
                     // rule list labels:
 16432   
                     // wildcard labels:
 16433  18 
                     retval.tree = root_0;
 16434  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16435  18 
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16436   
 
 16437  18 
                     root_0 = (Object)adaptor.nil();
 16438   
                     // 494:69: -> ^( GREATER $relationalExpression $n5)
 16439   
                     {
 16440  18 
                         // com\\googlecode\\sparkleg\\Sparql.g:494:72: ^( GREATER $relationalExpression $n5)
 16441   
                         {
 16442  18 
                         Object root_1 = (Object)adaptor.nil();
 16443  18 
                         root_1 = (Object)adaptor.becomeRoot(
 16444   
                         stream_GREATER.nextNode()
 16445   
                         , root_1);
 16446   
 
 16447  20 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16448  2 
 
 16449  18 
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16450   
 
 16451  20 
                         adaptor.addChild(root_0, root_1);
 16452  2 
                         }
 16453   
 
 16454  2 
                     }
 16455   
 
 16456  2 
 
 16457  18 
                     retval.tree = root_0;
 16458   
 
 16459   
                     }
 16460   
 
 16461   
 
 16462   
                     }
 16463  18 
                     break;
 16464   
                 case 5 :
 16465  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:495:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16466  2 
                     {
 16467  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:495:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16468   
                     // com\\googlecode\\sparkleg\\Sparql.g:495:40: LESS_EQUAL n6= numericExpression
 16469  2 
                     {
 16470  2 
                     LESS_EQUAL356=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4241);
 16471  2 
                     stream_LESS_EQUAL.add(LESS_EQUAL356);
 16472   
 
 16473   
 
 16474  4 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4245);
 16475  4 
                     n6=numericExpression();
 16476   
 
 16477  2 
                     state._fsp--;
 16478   
 
 16479  4 
                     stream_numericExpression.add(n6.getTree());
 16480   
 
 16481  2 
                     // AST REWRITE
 16482   
                     // elements: n6, relationalExpression, LESS_EQUAL
 16483  2 
                     // token labels:
 16484   
                     // rule labels: retval, n6
 16485   
                     // token list labels:
 16486   
                     // rule list labels:
 16487   
                     // wildcard labels:
 16488  2 
                     retval.tree = root_0;
 16489  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16490  2 
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16491   
 
 16492  2 
                     root_0 = (Object)adaptor.nil();
 16493   
                     // 495:72: -> ^( LESS_EQUAL $relationalExpression $n6)
 16494   
                     {
 16495  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:495:75: ^( LESS_EQUAL $relationalExpression $n6)
 16496   
                         {
 16497  2 
                         Object root_1 = (Object)adaptor.nil();
 16498  2 
                         root_1 = (Object)adaptor.becomeRoot(
 16499   
                         stream_LESS_EQUAL.nextNode()
 16500   
                         , root_1);
 16501   
 
 16502  5 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16503  3 
 
 16504  2 
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16505   
 
 16506  5 
                         adaptor.addChild(root_0, root_1);
 16507  3 
                         }
 16508   
 
 16509  3 
                     }
 16510   
 
 16511  3 
 
 16512  2 
                     retval.tree = root_0;
 16513   
 
 16514   
                     }
 16515   
 
 16516   
 
 16517   
                     }
 16518  2 
                     break;
 16519   
                 case 6 :
 16520  3 
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16521  3 
                     {
 16522  3 
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16523   
                     // com\\googlecode\\sparkleg\\Sparql.g:496:40: GREATER_EQUAL n7= numericExpression
 16524  3 
                     {
 16525  3 
                     GREATER_EQUAL357=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4299);
 16526  3 
                     stream_GREATER_EQUAL.add(GREATER_EQUAL357);
 16527   
 
 16528   
 
 16529  6 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4303);
 16530  6 
                     n7=numericExpression();
 16531   
 
 16532  3 
                     state._fsp--;
 16533   
 
 16534  6 
                     stream_numericExpression.add(n7.getTree());
 16535   
 
 16536  3 
                     // AST REWRITE
 16537   
                     // elements: relationalExpression, n7, GREATER_EQUAL
 16538  3 
                     // token labels:
 16539   
                     // rule labels: retval, n7
 16540   
                     // token list labels:
 16541   
                     // rule list labels:
 16542   
                     // wildcard labels:
 16543  3 
                     retval.tree = root_0;
 16544  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16545  3 
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16546   
 
 16547  3 
                     root_0 = (Object)adaptor.nil();
 16548   
                     // 496:75: -> ^( GREATER_EQUAL $relationalExpression $n7)
 16549   
                     {
 16550  3 
                         // com\\googlecode\\sparkleg\\Sparql.g:496:78: ^( GREATER_EQUAL $relationalExpression $n7)
 16551   
                         {
 16552  3 
                         Object root_1 = (Object)adaptor.nil();
 16553  3 
                         root_1 = (Object)adaptor.becomeRoot(
 16554   
                         stream_GREATER_EQUAL.nextNode()
 16555   
                         , root_1);
 16556   
 
 16557  5 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16558  2 
 
 16559  3 
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16560   
 
 16561  5 
                         adaptor.addChild(root_0, root_1);
 16562  2 
                         }
 16563   
 
 16564  2 
                     }
 16565   
 
 16566  2 
 
 16567  3 
                     retval.tree = root_0;
 16568   
 
 16569   
                     }
 16570   
 
 16571   
 
 16572   
                     }
 16573  3 
                     break;
 16574   
                 case 7 :
 16575  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16576  2 
                     {
 16577  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16578   
                     // com\\googlecode\\sparkleg\\Sparql.g:497:40: IN l2= expressionList
 16579  2 
                     {
 16580  2 
                     IN358=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4359);
 16581  2 
                     stream_IN.add(IN358);
 16582   
 
 16583   
 
 16584  4 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4363);
 16585  4 
                     l2=expressionList();
 16586   
 
 16587  2 
                     state._fsp--;
 16588   
 
 16589  4 
                     stream_expressionList.add(l2.getTree());
 16590   
 
 16591  2 
                     // AST REWRITE
 16592   
                     // elements: relationalExpression, l2, IN
 16593  2 
                     // token labels:
 16594   
                     // rule labels: retval, l2
 16595   
                     // token list labels:
 16596   
                     // rule list labels:
 16597   
                     // wildcard labels:
 16598  2 
                     retval.tree = root_0;
 16599  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16600  2 
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16601   
 
 16602  2 
                     root_0 = (Object)adaptor.nil();
 16603   
                     // 497:61: -> ^( IN $relationalExpression $l2)
 16604   
                     {
 16605  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:497:64: ^( IN $relationalExpression $l2)
 16606   
                         {
 16607  2 
                         Object root_1 = (Object)adaptor.nil();
 16608  2 
                         root_1 = (Object)adaptor.becomeRoot(
 16609   
                         stream_IN.nextNode()
 16610   
                         , root_1);
 16611   
 
 16612  4 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16613  2 
 
 16614  2 
                         adaptor.addChild(root_1, stream_l2.nextTree());
 16615   
 
 16616  4 
                         adaptor.addChild(root_0, root_1);
 16617  2 
                         }
 16618   
 
 16619   
                     }
 16620  2 
 
 16621  2 
 
 16622  2 
                     retval.tree = root_0;
 16623  2 
 
 16624   
                     }
 16625  2 
 
 16626   
 
 16627   
                     }
 16628  2 
                     break;
 16629   
                 case 8 :
 16630   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16631   
                     {
 16632   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16633   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:40: NOT IN l3= expressionList
 16634  2 
                     {
 16635  4 
                     NOT359=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4417);
 16636  4 
                     stream_NOT.add(NOT359);
 16637   
 
 16638  2 
 
 16639  2 
                     IN360=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4419);
 16640  2 
                     stream_IN.add(IN360);
 16641   
 
 16642   
 
 16643  4 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4423);
 16644  4 
                     l3=expressionList();
 16645   
 
 16646  2 
                     state._fsp--;
 16647   
 
 16648  4 
                     stream_expressionList.add(l3.getTree());
 16649   
 
 16650   
                     // AST REWRITE
 16651   
                     // elements: l3, IN, NOT, relationalExpression
 16652  2 
                     // token labels:
 16653   
                     // rule labels: retval, l3
 16654  2 
                     // token list labels:
 16655   
                     // rule list labels:
 16656  2 
                     // wildcard labels:
 16657  2 
                     retval.tree = root_0;
 16658  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16659  2 
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 16660   
 
 16661  2 
                     root_0 = (Object)adaptor.nil();
 16662  2 
                     // 498:65: -> ^( NOT IN $relationalExpression $l3)
 16663   
                     {
 16664   
                         // com\\googlecode\\sparkleg\\Sparql.g:498:68: ^( NOT IN $relationalExpression $l3)
 16665   
                         {
 16666  2 
                         Object root_1 = (Object)adaptor.nil();
 16667  2 
                         root_1 = (Object)adaptor.becomeRoot(
 16668   
                         stream_NOT.nextNode()
 16669   
                         , root_1);
 16670   
 
 16671  2 
                         adaptor.addChild(root_1,
 16672   
                         stream_IN.nextNode()
 16673   
                         );
 16674   
 
 16675  876 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16676   
 
 16677  2 
                         adaptor.addChild(root_1, stream_l3.nextTree());
 16678  874 
 
 16679  876 
                         adaptor.addChild(root_0, root_1);
 16680   
                         }
 16681   
 
 16682   
                     }
 16683   
 
 16684   
 
 16685  2 
                     retval.tree = root_0;
 16686   
 
 16687   
                     }
 16688   
 
 16689   
 
 16690   
                     }
 16691  874 
                     break;
 16692  874 
 
 16693   
             }
 16694   
 
 16695   
 
 16696   
             }
 16697  1081 
 
 16698  874 
             retval.stop = input.LT(-1);
 16699  1081 
 
 16700   
 
 16701  874 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16702  874 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16703   
 
 16704   
         }
 16705  0 
         catch (RecognitionException re) {
 16706  1081 
             reportError(re);
 16707  1081 
             recover(input,re);
 16708  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16709   
 
 16710  1081 
         }
 16711   
 
 16712  1081 
         finally {
 16713   
                 // do for sure before leaving
 16714  874 
         }
 16715  874 
         return retval;
 16716   
     }
 16717   
     // $ANTLR end "relationalExpression"
 16718   
 
 16719   
 
 16720  1081 
     public static class numericExpression_return extends ParserRuleReturnScope {
 16721   
         Object tree;
 16722  1081 
         public Object getTree() { return tree; }
 16723  1081 
     };
 16724  1081 
 
 16725   
 
 16726  1081 
     // $ANTLR start "numericExpression"
 16727   
     // com\\googlecode\\sparkleg\\Sparql.g:501:1: numericExpression : additiveExpression ;
 16728  1081 
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 16729  1081 
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 16730  1081 
         retval.start = input.LT(1);
 16731   
 
 16732  1081 
 
 16733  1081 
         Object root_0 = null;
 16734   
 
 16735  2162 
         SparqlParser.additiveExpression_return additiveExpression361 =null;
 16736  1081 
 
 16737   
 
 16738   
 
 16739   
         try {
 16740   
             // com\\googlecode\\sparkleg\\Sparql.g:502:5: ( additiveExpression )
 16741   
             // com\\googlecode\\sparkleg\\Sparql.g:502:7: additiveExpression
 16742   
             {
 16743  1081 
             root_0 = (Object)adaptor.nil();
 16744   
 
 16745   
 
 16746  1081 
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4457);
 16747  1081 
             additiveExpression361=additiveExpression();
 16748  1081 
 
 16749  2162 
             state._fsp--;
 16750   
 
 16751  1081 
             adaptor.addChild(root_0, additiveExpression361.getTree());
 16752   
 
 16753   
             }
 16754  1081 
 
 16755  1081 
             retval.stop = input.LT(-1);
 16756  1081 
 
 16757   
 
 16758  1081 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16759  1081 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16760   
 
 16761   
         }
 16762  0 
         catch (RecognitionException re) {
 16763  1081 
             reportError(re);
 16764  1081 
             recover(input,re);
 16765  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16766   
 
 16767  1081 
         }
 16768   
 
 16769  1081 
         finally {
 16770  1081 
                 // do for sure before leaving
 16771  2162 
         }
 16772  1081 
         return retval;
 16773  1081 
     }
 16774   
     // $ANTLR end "numericExpression"
 16775  1081 
 
 16776   
 
 16777  1081 
     public static class additiveExpression_return extends ParserRuleReturnScope {
 16778   
         Object tree;
 16779  1081 
         public Object getTree() { return tree; }
 16780   
     };
 16781  1081 
 
 16782   
 
 16783   
     // $ANTLR start "additiveExpression"
 16784  1081 
     // com\\googlecode\\sparkleg\\Sparql.g:505:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* ;
 16785  1081 
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 16786  2162 
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 16787  2162 
         retval.start = input.LT(1);
 16788  1081 
 
 16789  1081 
 
 16790  2162 
         Object root_0 = null;
 16791  1081 
 
 16792  2162 
         Token ASTERISK363=null;
 16793  1081 
         Token DIVIDE364=null;
 16794  1081 
         SparqlParser.multiplicativeExpression_return m1 =null;
 16795   
 
 16796  1081 
         SparqlParser.multiplicativeExpression_return m2 =null;
 16797   
 
 16798  1081 
         SparqlParser.numericLiteralPositive_return n1 =null;
 16799   
 
 16800  2162 
         SparqlParser.numericLiteralNegative_return n2 =null;
 16801  1081 
 
 16802  1081 
         SparqlParser.unaryExpression_return u2 =null;
 16803  1081 
 
 16804  1081 
         SparqlParser.additiveOperator_return additiveOperator362 =null;
 16805  1081 
 
 16806   
 
 16807  1081 
         Object ASTERISK363_tree=null;
 16808  1081 
         Object DIVIDE364_tree=null;
 16809  1081 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 16810  1081 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 16811  1081 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 16812  1081 
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 16813  1081 
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 16814  2162 
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 16815  2162 
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 16816  1081 
         try {
 16817   
             // com\\googlecode\\sparkleg\\Sparql.g:506:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* )
 16818  1081 
             // com\\googlecode\\sparkleg\\Sparql.g:506:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16819   
             {
 16820   
             // com\\googlecode\\sparkleg\\Sparql.g:506:7: (m1= multiplicativeExpression -> $m1)
 16821  1081 
             // com\\googlecode\\sparkleg\\Sparql.g:506:8: m1= multiplicativeExpression
 16822   
             {
 16823  1081 
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4477);
 16824  1081 
             m1=multiplicativeExpression();
 16825   
 
 16826  2162 
             state._fsp--;
 16827   
 
 16828  1081 
             stream_multiplicativeExpression.add(m1.getTree());
 16829   
 
 16830   
             // AST REWRITE
 16831   
             // elements: m1
 16832   
             // token labels:
 16833   
             // rule labels: retval, m1
 16834  1154 
             // token list labels:
 16835  1154 
             // rule list labels:
 16836   
             // wildcard labels:
 16837  1081 
             retval.tree = root_0;
 16838  1081 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16839  1134 
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 16840   
 
 16841  1134 
             root_0 = (Object)adaptor.nil();
 16842   
             // 506:36: -> $m1
 16843   
             {
 16844  1081 
                 adaptor.addChild(root_0, stream_m1.nextTree());
 16845   
 
 16846   
             }
 16847   
 
 16848   
 
 16849  1101 
             retval.tree = root_0;
 16850   
 
 16851   
             }
 16852   
 
 16853   
 
 16854   
             // com\\googlecode\\sparkleg\\Sparql.g:506:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16855  1154 
             loop122:
 16856   
             do {
 16857  1154 
                 int alt122=3;
 16858  1154 
                 switch ( input.LA(1) ) {
 16859   
                 case MINUS:
 16860   
                 case PLUS:
 16861   
                     {
 16862  106 
                     alt122=1;
 16863  53 
                     }
 16864  53 
                     break;
 16865  53 
                 case DECIMAL_NEGATIVE:
 16866   
                 case DECIMAL_POSITIVE:
 16867  53 
                 case DOUBLE_NEGATIVE:
 16868   
                 case DOUBLE_POSITIVE:
 16869  53 
                 case INTEGER_NEGATIVE:
 16870  53 
                 case INTEGER_POSITIVE:
 16871   
                     {
 16872  73 
                     alt122=2;
 16873   
                     }
 16874  53 
                     break;
 16875   
 
 16876   
                 }
 16877   
 
 16878  1154 
                 switch (alt122) {
 16879   
                     case 1 :
 16880   
                         // com\\googlecode\\sparkleg\\Sparql.g:506:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 16881   
                         {
 16882   
                         // com\\googlecode\\sparkleg\\Sparql.g:506:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 16883  53 
                         // com\\googlecode\\sparkleg\\Sparql.g:506:46: additiveOperator m2= multiplicativeExpression
 16884  53 
                         {
 16885  106 
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4487);
 16886  53 
                         additiveOperator362=additiveOperator();
 16887  53 
 
 16888  53 
                         state._fsp--;
 16889   
 
 16890  53 
                         stream_additiveOperator.add(additiveOperator362.getTree());
 16891   
 
 16892  106 
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4491);
 16893  106 
                         m2=multiplicativeExpression();
 16894   
 
 16895  106 
                         state._fsp--;
 16896   
 
 16897  106 
                         stream_multiplicativeExpression.add(m2.getTree());
 16898   
 
 16899  53 
                         // AST REWRITE
 16900   
                         // elements: additiveExpression, additiveOperator, m2
 16901   
                         // token labels:
 16902   
                         // rule labels: retval, m2
 16903   
                         // token list labels:
 16904   
                         // rule list labels:
 16905  53 
                         // wildcard labels:
 16906  53 
                         retval.tree = root_0;
 16907  53 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16908  53 
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 16909   
 
 16910  53 
                         root_0 = (Object)adaptor.nil();
 16911  53 
                         // 506:91: -> ^( additiveOperator $additiveExpression $m2)
 16912   
                         {
 16913   
                             // com\\googlecode\\sparkleg\\Sparql.g:506:94: ^( additiveOperator $additiveExpression $m2)
 16914   
                             {
 16915  53 
                             Object root_1 = (Object)adaptor.nil();
 16916  73 
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 16917  20 
 
 16918  53 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16919   
 
 16920  53 
                             adaptor.addChild(root_1, stream_m2.nextTree());
 16921   
 
 16922  73 
                             adaptor.addChild(root_0, root_1);
 16923   
                             }
 16924  20 
 
 16925   
                         }
 16926   
 
 16927   
 
 16928  53 
                         retval.tree = root_0;
 16929   
 
 16930   
                         }
 16931   
 
 16932   
 
 16933   
                         }
 16934  53 
                         break;
 16935   
                     case 2 :
 16936   
                         // com\\googlecode\\sparkleg\\Sparql.g:507:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 16937   
                         {
 16938   
                         // com\\googlecode\\sparkleg\\Sparql.g:507:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) )
 16939  20 
                         int alt120=2;
 16940  40 
                         switch ( input.LA(1) ) {
 16941   
                         case DECIMAL_POSITIVE:
 16942   
                         case DOUBLE_POSITIVE:
 16943   
                         case INTEGER_POSITIVE:
 16944  20 
                             {
 16945  40 
                             alt120=1;
 16946   
                             }
 16947  40 
                             break;
 16948   
                         case DECIMAL_NEGATIVE:
 16949  20 
                         case DOUBLE_NEGATIVE:
 16950   
                         case INTEGER_NEGATIVE:
 16951   
                             {
 16952  0 
                             alt120=2;
 16953   
                             }
 16954  0 
                             break;
 16955   
                         default:
 16956  0 
                             NoViableAltException nvae =
 16957   
                                 new NoViableAltException("", 120, 0, input);
 16958  20 
 
 16959  20 
                             throw nvae;
 16960  20 
 
 16961   
                         }
 16962  20 
 
 16963  20 
                         switch (alt120) {
 16964   
                             case 1 :
 16965   
                                 // com\\googlecode\\sparkleg\\Sparql.g:507:49: n1= numericLiteralPositive
 16966   
                                 {
 16967  40 
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4558);
 16968  40 
                                 n1=numericLiteralPositive();
 16969   
 
 16970  20 
                                 state._fsp--;
 16971   
 
 16972  40 
                                 stream_numericLiteralPositive.add(n1.getTree());
 16973   
 
 16974  20 
                                 // AST REWRITE
 16975   
                                 // elements: n1, additiveExpression
 16976  20 
                                 // token labels:
 16977   
                                 // rule labels: n1, retval
 16978   
                                 // token list labels:
 16979   
                                 // rule list labels:
 16980   
                                 // wildcard labels:
 16981  20 
                                 retval.tree = root_0;
 16982  40 
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16983  20 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16984   
 
 16985  40 
                                 root_0 = (Object)adaptor.nil();
 16986   
                                 // 507:75: -> ^( PLUS $additiveExpression $n1)
 16987   
                                 {
 16988   
                                     // com\\googlecode\\sparkleg\\Sparql.g:507:78: ^( PLUS $additiveExpression $n1)
 16989   
                                     {
 16990  20 
                                     Object root_1 = (Object)adaptor.nil();
 16991  20 
                                     root_1 = (Object)adaptor.becomeRoot(
 16992   
                                     (Object)adaptor.create(PLUS, "PLUS")
 16993   
                                     , root_1);
 16994   
 
 16995  20 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 16996   
 
 16997  20 
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 16998   
 
 16999  20 
                                     adaptor.addChild(root_0, root_1);
 17000   
                                     }
 17001   
 
 17002   
                                 }
 17003   
 
 17004   
 
 17005  20 
                                 retval.tree = root_0;
 17006   
 
 17007   
                                 }
 17008  20 
                                 break;
 17009   
                             case 2 :
 17010   
                                 // com\\googlecode\\sparkleg\\Sparql.g:507:112: n2= numericLiteralNegative
 17011   
                                 {
 17012  0 
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4576);
 17013  0 
                                 n2=numericLiteralNegative();
 17014   
 
 17015  0 
                                 state._fsp--;
 17016   
 
 17017  0 
                                 stream_numericLiteralNegative.add(n2.getTree());
 17018   
 
 17019   
                                 // AST REWRITE
 17020   
                                 // elements: n2, additiveExpression
 17021   
                                 // token labels:
 17022   
                                 // rule labels: retval, n2
 17023   
                                 // token list labels:
 17024   
                                 // rule list labels:
 17025   
                                 // wildcard labels:
 17026  0 
                                 retval.tree = root_0;
 17027  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17028  0 
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17029   
 
 17030  0 
                                 root_0 = (Object)adaptor.nil();
 17031   
                                 // 507:138: -> ^( PLUS $additiveExpression $n2)
 17032   
                                 {
 17033   
                                     // com\\googlecode\\sparkleg\\Sparql.g:507:141: ^( PLUS $additiveExpression $n2)
 17034   
                                     {
 17035  0 
                                     Object root_1 = (Object)adaptor.nil();
 17036  20 
                                     root_1 = (Object)adaptor.becomeRoot(
 17037  20 
                                     (Object)adaptor.create(PLUS, "PLUS")
 17038   
                                     , root_1);
 17039   
 
 17040  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17041   
 
 17042  0 
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17043   
 
 17044  0 
                                     adaptor.addChild(root_0, root_1);
 17045   
                                     }
 17046   
 
 17047   
                                 }
 17048   
 
 17049   
 
 17050  20 
                                 retval.tree = root_0;
 17051   
 
 17052   
                                 }
 17053   
                                 break;
 17054   
 
 17055   
                         }
 17056   
 
 17057   
 
 17058   
                         // com\\googlecode\\sparkleg\\Sparql.g:508:46: ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17059  20 
                         int alt121=3;
 17060  20 
                         switch ( input.LA(1) ) {
 17061   
                             case ASTERISK:
 17062   
                                 {
 17063  0 
                                 alt121=1;
 17064   
                                 }
 17065  0 
                                 break;
 17066   
                             case DIVIDE:
 17067   
                                 {
 17068  0 
                                 alt121=2;
 17069   
                                 }
 17070   
                                 break;
 17071   
                         }
 17072   
 
 17073  20 
                         switch (alt121) {
 17074   
                             case 1 :
 17075   
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17076   
                                 {
 17077   
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17078   
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17079   
                                 {
 17080   
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17081   
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:49: ASTERISK u2= unaryExpression
 17082   
                                 {
 17083  0 
                                 ASTERISK363=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4640);
 17084  0 
                                 stream_ASTERISK.add(ASTERISK363);
 17085   
 
 17086   
 
 17087  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4644);
 17088  0 
                                 u2=unaryExpression();
 17089   
 
 17090  0 
                                 state._fsp--;
 17091   
 
 17092  0 
                                 stream_unaryExpression.add(u2.getTree());
 17093   
 
 17094   
                                 // AST REWRITE
 17095   
                                 // elements: additiveExpression, ASTERISK, u2
 17096   
                                 // token labels:
 17097   
                                 // rule labels: retval, u2
 17098   
                                 // token list labels:
 17099   
                                 // rule list labels:
 17100   
                                 // wildcard labels:
 17101  0 
                                 retval.tree = root_0;
 17102  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17103  0 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17104   
 
 17105  0 
                                 root_0 = (Object)adaptor.nil();
 17106   
                                 // 508:77: -> ^( ASTERISK $additiveExpression $u2)
 17107   
                                 {
 17108   
                                     // com\\googlecode\\sparkleg\\Sparql.g:508:80: ^( ASTERISK $additiveExpression $u2)
 17109   
                                     {
 17110  0 
                                     Object root_1 = (Object)adaptor.nil();
 17111  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17112   
                                     stream_ASTERISK.nextNode()
 17113   
                                     , root_1);
 17114   
 
 17115  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17116   
 
 17117  0 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17118   
 
 17119  0 
                                     adaptor.addChild(root_0, root_1);
 17120   
                                     }
 17121   
 
 17122   
                                 }
 17123   
 
 17124   
 
 17125  0 
                                 retval.tree = root_0;
 17126   
 
 17127   
                                 }
 17128   
 
 17129   
 
 17130   
                                 }
 17131   
 
 17132   
 
 17133   
                                 }
 17134  0 
                                 break;
 17135   
                             case 2 :
 17136   
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17137   
                                 {
 17138   
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17139   
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17140   
                                 {
 17141   
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17142   
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:50: DIVIDE u2= unaryExpression
 17143   
                                 {
 17144  0 
                                 DIVIDE364=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4710);
 17145  0 
                                 stream_DIVIDE.add(DIVIDE364);
 17146   
 
 17147   
 
 17148  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4714);
 17149  0 
                                 u2=unaryExpression();
 17150   
 
 17151  0 
                                 state._fsp--;
 17152   
 
 17153  0 
                                 stream_unaryExpression.add(u2.getTree());
 17154   
 
 17155   
                                 // AST REWRITE
 17156   
                                 // elements: additiveExpression, DIVIDE, u2
 17157   
                                 // token labels:
 17158   
                                 // rule labels: retval, u2
 17159   
                                 // token list labels:
 17160   
                                 // rule list labels:
 17161   
                                 // wildcard labels:
 17162  0 
                                 retval.tree = root_0;
 17163  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17164  0 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17165   
 
 17166  0 
                                 root_0 = (Object)adaptor.nil();
 17167   
                                 // 509:76: -> ^( DIVIDE $additiveExpression $u2)
 17168   
                                 {
 17169   
                                     // com\\googlecode\\sparkleg\\Sparql.g:509:79: ^( DIVIDE $additiveExpression $u2)
 17170   
                                     {
 17171  0 
                                     Object root_1 = (Object)adaptor.nil();
 17172  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17173   
                                     stream_DIVIDE.nextNode()
 17174   
                                     , root_1);
 17175   
 
 17176  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17177   
 
 17178  20 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17179   
 
 17180  0 
                                     adaptor.addChild(root_0, root_1);
 17181  1081 
                                     }
 17182   
 
 17183  73 
                                 }
 17184   
 
 17185   
 
 17186  0 
                                 retval.tree = root_0;
 17187   
 
 17188  1081 
                                 }
 17189   
 
 17190   
 
 17191  1081 
                                 }
 17192  1081 
 
 17193   
 
 17194   
                                 }
 17195   
                                 break;
 17196   
 
 17197   
                         }
 17198   
 
 17199   
 
 17200   
                         }
 17201  20 
                         break;
 17202   
 
 17203   
                     default :
 17204  2162 
                         break loop122;
 17205  1081 
                 }
 17206  73 
             } while (true);
 17207   
 
 17208   
 
 17209   
             }
 17210  53 
 
 17211  1081 
             retval.stop = input.LT(-1);
 17212  53 
 
 17213   
 
 17214  1081 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17215  1081 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17216   
 
 17217   
         }
 17218  0 
         catch (RecognitionException re) {
 17219  53 
             reportError(re);
 17220  53 
             recover(input,re);
 17221  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17222   
 
 17223  53 
         }
 17224   
 
 17225  53 
         finally {
 17226   
                 // do for sure before leaving
 17227  1134 
         }
 17228  1081 
         return retval;
 17229   
     }
 17230   
     // $ANTLR end "additiveExpression"
 17231   
 
 17232   
 
 17233  53 
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17234   
         Object tree;
 17235  53 
         public Object getTree() { return tree; }
 17236  53 
     };
 17237   
 
 17238  53 
 
 17239  53 
     // $ANTLR start "additiveOperator"
 17240  53 
     // com\\googlecode\\sparkleg\\Sparql.g:512:1: additiveOperator : ( PLUS | MINUS );
 17241   
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17242  53 
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17243  106 
         retval.start = input.LT(1);
 17244   
 
 17245   
 
 17246  53 
         Object root_0 = null;
 17247   
 
 17248  53 
         Token set365=null;
 17249   
 
 17250  53 
         Object set365_tree=null;
 17251   
 
 17252   
         try {
 17253  53 
             // com\\googlecode\\sparkleg\\Sparql.g:513:5: ( PLUS | MINUS )
 17254   
             // com\\googlecode\\sparkleg\\Sparql.g:
 17255   
             {
 17256  106 
             root_0 = (Object)adaptor.nil();
 17257  53 
 
 17258   
 
 17259  53 
             set365=(Token)input.LT(1);
 17260   
 
 17261  53 
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17262  53 
                 input.consume();
 17263  53 
                 adaptor.addChild(root_0,
 17264   
                 (Object)adaptor.create(set365)
 17265   
                 );
 17266  53 
                 state.errorRecovery=false;
 17267   
             }
 17268   
             else {
 17269  53 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17270  53 
                 throw mse;
 17271   
             }
 17272   
 
 17273   
 
 17274   
             }
 17275  1134 
 
 17276  53 
             retval.stop = input.LT(-1);
 17277  1134 
 
 17278   
 
 17279  53 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17280  53 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17281   
 
 17282   
         }
 17283  0 
         catch (RecognitionException re) {
 17284  1134 
             reportError(re);
 17285  1134 
             recover(input,re);
 17286  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17287   
 
 17288  1134 
         }
 17289   
 
 17290  1134 
         finally {
 17291   
                 // do for sure before leaving
 17292  1187 
         }
 17293  53 
         return retval;
 17294  1134 
     }
 17295   
     // $ANTLR end "additiveOperator"
 17296   
 
 17297  1134 
 
 17298  1134 
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17299   
         Object tree;
 17300  1134 
         public Object getTree() { return tree; }
 17301   
     };
 17302   
 
 17303   
 
 17304   
     // $ANTLR start "multiplicativeExpression"
 17305   
     // com\\googlecode\\sparkleg\\Sparql.g:516:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17306  1134 
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17307  2268 
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17308  1134 
         retval.start = input.LT(1);
 17309  1134 
 
 17310   
 
 17311  2268 
         Object root_0 = null;
 17312   
 
 17313  1134 
         SparqlParser.unaryExpression_return u1 =null;
 17314   
 
 17315  1134 
         SparqlParser.unaryExpression_return u2 =null;
 17316   
 
 17317  1134 
         SparqlParser.multiplicativeOperator_return multiplicativeOperator366 =null;
 17318   
 
 17319   
 
 17320  2268 
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17321  2268 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17322  1134 
         try {
 17323   
             // com\\googlecode\\sparkleg\\Sparql.g:517:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17324  1134 
             // com\\googlecode\\sparkleg\\Sparql.g:517:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17325   
             {
 17326   
             // com\\googlecode\\sparkleg\\Sparql.g:517:7: (u1= unaryExpression -> $u1)
 17327  1134 
             // com\\googlecode\\sparkleg\\Sparql.g:517:8: u1= unaryExpression
 17328   
             {
 17329  1134 
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4780);
 17330  1134 
             u1=unaryExpression();
 17331   
 
 17332  2268 
             state._fsp--;
 17333   
 
 17334  1134 
             stream_unaryExpression.add(u1.getTree());
 17335   
 
 17336   
             // AST REWRITE
 17337   
             // elements: u1
 17338   
             // token labels:
 17339   
             // rule labels: retval, u1
 17340  1150 
             // token list labels:
 17341  1150 
             // rule list labels:
 17342   
             // wildcard labels:
 17343  1134 
             retval.tree = root_0;
 17344  1134 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17345  1150 
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17346   
 
 17347  1134 
             root_0 = (Object)adaptor.nil();
 17348   
             // 517:27: -> $u1
 17349   
             {
 17350  1134 
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17351  1150 
 
 17352   
             }
 17353   
 
 17354   
 
 17355  1150 
             retval.tree = root_0;
 17356  16 
 
 17357   
             }
 17358  16 
 
 17359   
 
 17360  16 
             // com\\googlecode\\sparkleg\\Sparql.g:517:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17361   
             loop123:
 17362  16 
             do {
 17363  1166 
                 int alt123=2;
 17364  1150 
                 switch ( input.LA(1) ) {
 17365  16 
                 case ASTERISK:
 17366   
                 case DIVIDE:
 17367  16 
                     {
 17368  16 
                     alt123=1;
 17369   
                     }
 17370   
                     break;
 17371   
 
 17372   
                 }
 17373   
 
 17374  1150 
                 switch (alt123) {
 17375   
                     case 1 :
 17376  16 
                         // com\\googlecode\\sparkleg\\Sparql.g:517:36: multiplicativeOperator u2= unaryExpression
 17377  16 
                         {
 17378  32 
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression4789);
 17379  16 
                         multiplicativeOperator366=multiplicativeOperator();
 17380  16 
 
 17381  16 
                         state._fsp--;
 17382   
 
 17383  16 
                         stream_multiplicativeOperator.add(multiplicativeOperator366.getTree());
 17384   
 
 17385  32 
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4793);
 17386  32 
                         u2=unaryExpression();
 17387   
 
 17388  32 
                         state._fsp--;
 17389   
 
 17390  32 
                         stream_unaryExpression.add(u2.getTree());
 17391   
 
 17392  16 
                         // AST REWRITE
 17393   
                         // elements: multiplicativeOperator, u2, multiplicativeExpression
 17394   
                         // token labels:
 17395   
                         // rule labels: retval, u2
 17396   
                         // token list labels:
 17397   
                         // rule list labels:
 17398  16 
                         // wildcard labels:
 17399  16 
                         retval.tree = root_0;
 17400  16 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17401  32 
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17402   
 
 17403  16 
                         root_0 = (Object)adaptor.nil();
 17404  1134 
                         // 517:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17405   
                         {
 17406  16 
                             // com\\googlecode\\sparkleg\\Sparql.g:517:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17407   
                             {
 17408  16 
                             Object root_1 = (Object)adaptor.nil();
 17409  16 
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17410   
 
 17411  1150 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17412   
 
 17413  16 
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17414  1134 
 
 17415  1150 
                             adaptor.addChild(root_0, root_1);
 17416   
                             }
 17417   
 
 17418   
                         }
 17419   
 
 17420   
 
 17421  16 
                         retval.tree = root_0;
 17422   
 
 17423   
                         }
 17424  16 
                         break;
 17425   
 
 17426   
                     default :
 17427  2268 
                         break loop123;
 17428  1134 
                 }
 17429  16 
             } while (true);
 17430   
 
 17431   
 
 17432   
             }
 17433  16 
 
 17434  1134 
             retval.stop = input.LT(-1);
 17435  16 
 
 17436   
 
 17437  1134 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17438  1134 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17439   
 
 17440   
         }
 17441  0 
         catch (RecognitionException re) {
 17442  16 
             reportError(re);
 17443  16 
             recover(input,re);
 17444  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17445   
 
 17446  16 
         }
 17447   
 
 17448  16 
         finally {
 17449   
                 // do for sure before leaving
 17450  1150 
         }
 17451  1134 
         return retval;
 17452   
     }
 17453   
     // $ANTLR end "multiplicativeExpression"
 17454   
 
 17455   
 
 17456  16 
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17457   
         Object tree;
 17458  16 
         public Object getTree() { return tree; }
 17459  16 
     };
 17460   
 
 17461  16 
 
 17462  16 
     // $ANTLR start "multiplicativeOperator"
 17463  16 
     // com\\googlecode\\sparkleg\\Sparql.g:520:1: multiplicativeOperator : ( ASTERISK | DIVIDE );
 17464   
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17465  16 
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17466  32 
         retval.start = input.LT(1);
 17467   
 
 17468   
 
 17469  16 
         Object root_0 = null;
 17470   
 
 17471  16 
         Token set367=null;
 17472   
 
 17473  16 
         Object set367_tree=null;
 17474   
 
 17475   
         try {
 17476  16 
             // com\\googlecode\\sparkleg\\Sparql.g:521:5: ( ASTERISK | DIVIDE )
 17477   
             // com\\googlecode\\sparkleg\\Sparql.g:
 17478   
             {
 17479  32 
             root_0 = (Object)adaptor.nil();
 17480  16 
 
 17481   
 
 17482  16 
             set367=(Token)input.LT(1);
 17483   
 
 17484  16 
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17485  16 
                 input.consume();
 17486  16 
                 adaptor.addChild(root_0,
 17487   
                 (Object)adaptor.create(set367)
 17488   
                 );
 17489  16 
                 state.errorRecovery=false;
 17490   
             }
 17491   
             else {
 17492  16 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17493  16 
                 throw mse;
 17494   
             }
 17495   
 
 17496   
 
 17497   
             }
 17498  1150 
 
 17499  16 
             retval.stop = input.LT(-1);
 17500  1150 
 
 17501   
 
 17502  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17503  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17504   
 
 17505   
         }
 17506  0 
         catch (RecognitionException re) {
 17507  1150 
             reportError(re);
 17508  1150 
             recover(input,re);
 17509  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17510   
 
 17511  1150 
         }
 17512   
 
 17513  1150 
         finally {
 17514  1150 
                 // do for sure before leaving
 17515  1166 
         }
 17516  1166 
         return retval;
 17517   
     }
 17518  1150 
     // $ANTLR end "multiplicativeOperator"
 17519   
 
 17520  1150 
 
 17521  1150 
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17522  1150 
         Object tree;
 17523  1150 
         public Object getTree() { return tree; }
 17524   
     };
 17525  1150 
 
 17526  1150 
 
 17527  1150 
     // $ANTLR start "unaryExpression"
 17528  1150 
     // com\\googlecode\\sparkleg\\Sparql.g:524:1: unaryExpression : ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17529  1150 
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17530  2300 
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17531  2300 
         retval.start = input.LT(1);
 17532   
 
 17533   
 
 17534  2300 
         Object root_0 = null;
 17535  1150 
 
 17536  1150 
         Token NEGATION368=null;
 17537  1150 
         Token PLUS370=null;
 17538  1169 
         Token MINUS372=null;
 17539  1150 
         SparqlParser.primaryExpression_return primaryExpression369 =null;
 17540  19 
 
 17541  1150 
         SparqlParser.primaryExpression_return primaryExpression371 =null;
 17542   
 
 17543  1150 
         SparqlParser.primaryExpression_return primaryExpression373 =null;
 17544   
 
 17545  1150 
         SparqlParser.primaryExpression_return primaryExpression374 =null;
 17546   
 
 17547   
 
 17548  1151 
         Object NEGATION368_tree=null;
 17549  1150 
         Object PLUS370_tree=null;
 17550  1151 
         Object MINUS372_tree=null;
 17551  1150 
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17552  1150 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17553  1150 
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17554  1150 
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17555   
         try {
 17556   
             // com\\googlecode\\sparkleg\\Sparql.g:525:5: ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17557  1150 
             int alt124=4;
 17558  1150 
             switch ( input.LA(1) ) {
 17559   
             case NEGATION:
 17560   
                 {
 17561  19 
                 alt124=1;
 17562   
                 }
 17563  19 
                 break;
 17564   
             case PLUS:
 17565   
                 {
 17566  0 
                 alt124=2;
 17567   
                 }
 17568  0 
                 break;
 17569   
             case MINUS:
 17570   
                 {
 17571  1 
                 alt124=3;
 17572   
                 }
 17573  1 
                 break;
 17574   
             case ABS:
 17575   
             case AVG:
 17576   
             case BNODE:
 17577   
             case BOUND:
 17578   
             case CEIL:
 17579   
             case COALESCE:
 17580   
             case CONCAT:
 17581   
             case CONTAINS:
 17582   
             case COUNT:
 17583   
             case DATATYPE:
 17584   
             case DAY:
 17585   
             case DECIMAL:
 17586   
             case DECIMAL_NEGATIVE:
 17587   
             case DECIMAL_POSITIVE:
 17588   
             case DOUBLE:
 17589   
             case DOUBLE_NEGATIVE:
 17590   
             case DOUBLE_POSITIVE:
 17591   
             case ENCODE_FOR_URI:
 17592   
             case EXISTS:
 17593   
             case FALSE:
 17594   
             case FLOOR:
 17595   
             case GROUP_CONCAT:
 17596   
             case HOURS:
 17597   
             case IF:
 17598   
             case INTEGER:
 17599   
             case INTEGER_NEGATIVE:
 17600   
             case INTEGER_POSITIVE:
 17601   
             case IRI:
 17602   
             case IRI_REF:
 17603   
             case ISBLANK:
 17604   
             case ISIRI:
 17605   
             case ISLITERAL:
 17606   
             case ISNUMERIC:
 17607   
             case ISURI:
 17608   
             case LANG:
 17609   
             case LANGMATCHES:
 17610   
             case LCASE:
 17611   
             case MAX:
 17612   
             case MD5:
 17613   
             case MIN:
 17614   
             case MINUTES:
 17615   
             case MONTH:
 17616   
             case NOT:
 17617   
             case NOW:
 17618   
             case OPEN_BRACE:
 17619   
             case PNAME_LN:
 17620   
             case PNAME_NS:
 17621   
             case RAND:
 17622   
             case REGEX:
 17623   
             case REPLACE:
 17624   
             case ROUND:
 17625   
             case SAMETERM:
 17626   
             case SAMPLE:
 17627   
             case SECONDS:
 17628   
             case SHA1:
 17629   
             case SHA224:
 17630   
             case SHA256:
 17631   
             case SHA384:
 17632   
             case SHA512:
 17633  1128 
             case STR:
 17634   
             case STRAFTER:
 17635  1128 
             case STRBEFORE:
 17636   
             case STRDT:
 17637  2 
             case STRENDS:
 17638   
             case STRING_LITERAL1:
 17639   
             case STRING_LITERAL2:
 17640  2 
             case STRING_LITERAL_LONG1:
 17641   
             case STRING_LITERAL_LONG2:
 17642   
             case STRLANG:
 17643   
             case STRLEN:
 17644  1148 
             case STRSTARTS:
 17645   
             case SUBSTR:
 17646   
             case SUM:
 17647   
             case TIMEZONE:
 17648  19 
             case TRUE:
 17649  19 
             case TZ:
 17650   
             case UCASE:
 17651   
             case URI:
 17652  19 
             case VAR1:
 17653  19 
             case VAR2:
 17654   
             case YEAR:
 17655  19 
                 {
 17656  1128 
                 alt124=4;
 17657  19 
                 }
 17658  1128 
                 break;
 17659   
             default:
 17660  2 
                 NoViableAltException nvae =
 17661   
                     new NoViableAltException("", 124, 0, input);
 17662   
 
 17663  2 
                 throw nvae;
 17664   
 
 17665   
             }
 17666  19 
 
 17667  1167 
             switch (alt124) {
 17668   
                 case 1 :
 17669  19 
                     // com\\googlecode\\sparkleg\\Sparql.g:525:7: NEGATION primaryExpression
 17670   
                     {
 17671  19 
                     NEGATION368=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression4849);
 17672  19 
                     stream_NEGATION.add(NEGATION368);
 17673   
 
 17674  19 
 
 17675  38 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4851);
 17676  19 
                     primaryExpression369=primaryExpression();
 17677   
 
 17678  19 
                     state._fsp--;
 17679  19 
 
 17680  19 
                     stream_primaryExpression.add(primaryExpression369.getTree());
 17681   
 
 17682   
                     // AST REWRITE
 17683  19 
                     // elements: NEGATION, primaryExpression
 17684   
                     // token labels:
 17685  19 
                     // rule labels: retval
 17686   
                     // token list labels:
 17687   
                     // rule list labels:
 17688   
                     // wildcard labels:
 17689  19 
                     retval.tree = root_0;
 17690  19 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17691  19 
 
 17692  19 
                     root_0 = (Object)adaptor.nil();
 17693   
                     // 525:34: -> ^( UNARY NEGATION primaryExpression )
 17694  19 
                     {
 17695   
                         // com\\googlecode\\sparkleg\\Sparql.g:525:37: ^( UNARY NEGATION primaryExpression )
 17696   
                         {
 17697  19 
                         Object root_1 = (Object)adaptor.nil();
 17698  19 
                         root_1 = (Object)adaptor.becomeRoot(
 17699   
                         (Object)adaptor.create(UNARY, "UNARY")
 17700   
                         , root_1);
 17701   
 
 17702  19 
                         adaptor.addChild(root_1,
 17703   
                         stream_NEGATION.nextNode()
 17704   
                         );
 17705   
 
 17706  19 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17707   
 
 17708  19 
                         adaptor.addChild(root_0, root_1);
 17709   
                         }
 17710   
 
 17711   
                     }
 17712   
 
 17713   
 
 17714  19 
                     retval.tree = root_0;
 17715   
 
 17716   
                     }
 17717  19 
                     break;
 17718   
                 case 2 :
 17719   
                     // com\\googlecode\\sparkleg\\Sparql.g:526:7: PLUS primaryExpression
 17720   
                     {
 17721  0 
                     PLUS370=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression4869);
 17722  0 
                     stream_PLUS.add(PLUS370);
 17723   
 
 17724   
 
 17725  0 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4871);
 17726  0 
                     primaryExpression371=primaryExpression();
 17727   
 
 17728  0 
                     state._fsp--;
 17729   
 
 17730  0 
                     stream_primaryExpression.add(primaryExpression371.getTree());
 17731   
 
 17732   
                     // AST REWRITE
 17733   
                     // elements: primaryExpression, PLUS
 17734   
                     // token labels:
 17735   
                     // rule labels: retval
 17736   
                     // token list labels:
 17737   
                     // rule list labels:
 17738   
                     // wildcard labels:
 17739  0 
                     retval.tree = root_0;
 17740  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17741   
 
 17742  0 
                     root_0 = (Object)adaptor.nil();
 17743   
                     // 526:30: -> ^( UNARY PLUS primaryExpression )
 17744   
                     {
 17745   
                         // com\\googlecode\\sparkleg\\Sparql.g:526:33: ^( UNARY PLUS primaryExpression )
 17746   
                         {
 17747  0 
                         Object root_1 = (Object)adaptor.nil();
 17748  1 
                         root_1 = (Object)adaptor.becomeRoot(
 17749  1 
                         (Object)adaptor.create(UNARY, "UNARY")
 17750   
                         , root_1);
 17751   
 
 17752  1 
                         adaptor.addChild(root_1,
 17753  1 
                         stream_PLUS.nextNode()
 17754   
                         );
 17755  1 
 
 17756  0 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17757  1 
 
 17758  0 
                         adaptor.addChild(root_0, root_1);
 17759   
                         }
 17760   
 
 17761   
                     }
 17762   
 
 17763   
 
 17764  0 
                     retval.tree = root_0;
 17765   
 
 17766  1 
                     }
 17767  1 
                     break;
 17768   
                 case 3 :
 17769  1 
                     // com\\googlecode\\sparkleg\\Sparql.g:527:7: MINUS primaryExpression
 17770   
                     {
 17771  1 
                     MINUS372=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression4889);
 17772  1 
                     stream_MINUS.add(MINUS372);
 17773   
 
 17774  1 
 
 17775  2 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4891);
 17776  1 
                     primaryExpression373=primaryExpression();
 17777   
 
 17778  1 
                     state._fsp--;
 17779  1 
 
 17780  1 
                     stream_primaryExpression.add(primaryExpression373.getTree());
 17781   
 
 17782   
                     // AST REWRITE
 17783  1 
                     // elements: primaryExpression, MINUS
 17784   
                     // token labels:
 17785  1 
                     // rule labels: retval
 17786   
                     // token list labels:
 17787   
                     // rule list labels:
 17788   
                     // wildcard labels:
 17789  1 
                     retval.tree = root_0;
 17790  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17791  1 
 
 17792  1 
                     root_0 = (Object)adaptor.nil();
 17793   
                     // 527:31: -> ^( UNARY MINUS primaryExpression )
 17794  1 
                     {
 17795   
                         // com\\googlecode\\sparkleg\\Sparql.g:527:34: ^( UNARY MINUS primaryExpression )
 17796   
                         {
 17797  1 
                         Object root_1 = (Object)adaptor.nil();
 17798  1129 
                         root_1 = (Object)adaptor.becomeRoot(
 17799  1128 
                         (Object)adaptor.create(UNARY, "UNARY")
 17800   
                         , root_1);
 17801  1128 
 
 17802  1 
                         adaptor.addChild(root_1,
 17803  1128 
                         stream_MINUS.nextNode()
 17804   
                         );
 17805   
 
 17806  1 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17807   
 
 17808  1 
                         adaptor.addChild(root_0, root_1);
 17809   
                         }
 17810   
 
 17811   
                     }
 17812  1128 
 
 17813  1128 
 
 17814  1 
                     retval.tree = root_0;
 17815  1128 
 
 17816   
                     }
 17817  1 
                     break;
 17818   
                 case 4 :
 17819   
                     // com\\googlecode\\sparkleg\\Sparql.g:528:7: primaryExpression
 17820  1128 
                     {
 17821  2256 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4909);
 17822  1128 
                     primaryExpression374=primaryExpression();
 17823   
 
 17824  1128 
                     state._fsp--;
 17825  1128 
 
 17826  1128 
                     stream_primaryExpression.add(primaryExpression374.getTree());
 17827  1128 
 
 17828   
                     // AST REWRITE
 17829   
                     // elements: primaryExpression
 17830   
                     // token labels:
 17831   
                     // rule labels: retval
 17832   
                     // token list labels:
 17833  1128 
                     // rule list labels:
 17834   
                     // wildcard labels:
 17835  1128 
                     retval.tree = root_0;
 17836  1128 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17837   
 
 17838  1128 
                     root_0 = (Object)adaptor.nil();
 17839  1148 
                     // 528:25: -> ^( UNARY primaryExpression )
 17840   
                     {
 17841   
                         // com\\googlecode\\sparkleg\\Sparql.g:528:28: ^( UNARY primaryExpression )
 17842  1148 
                         {
 17843  2276 
                         Object root_1 = (Object)adaptor.nil();
 17844  1128 
                         root_1 = (Object)adaptor.becomeRoot(
 17845   
                         (Object)adaptor.create(UNARY, "UNARY")
 17846  2 
                         , root_1);
 17847  2 
 
 17848  1130 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17849  2 
 
 17850  1128 
                         adaptor.addChild(root_0, root_1);
 17851   
                         }
 17852   
 
 17853   
                     }
 17854   
 
 17855  1150 
 
 17856  2278 
                     retval.tree = root_0;
 17857   
 
 17858   
                     }
 17859   
                     break;
 17860   
 
 17861  1148 
             }
 17862  1148 
             retval.stop = input.LT(-1);
 17863  1148 
 
 17864   
 
 17865  1148 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17866  1148 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17867   
 
 17868   
         }
 17869  2 
         catch (RecognitionException re) {
 17870  1150 
             reportError(re);
 17871  1150 
             recover(input,re);
 17872  2 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17873   
 
 17874  1148 
         }
 17875   
 
 17876  1148 
         finally {
 17877   
                 // do for sure before leaving
 17878  2298 
         }
 17879  1150 
         return retval;
 17880  1148 
     }
 17881   
     // $ANTLR end "unaryExpression"
 17882  1148 
 
 17883   
 
 17884  1148 
     public static class primaryExpression_return extends ParserRuleReturnScope {
 17885   
         Object tree;
 17886  1148 
         public Object getTree() { return tree; }
 17887   
     };
 17888  1148 
 
 17889   
 
 17890  1148 
     // $ANTLR start "primaryExpression"
 17891   
     // com\\googlecode\\sparkleg\\Sparql.g:531:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 17892   
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 17893  1148 
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 17894  1148 
         retval.start = input.LT(1);
 17895   
 
 17896  1148 
 
 17897  2296 
         Object root_0 = null;
 17898   
 
 17899  1148 
         SparqlParser.brackettedExpression_return brackettedExpression375 =null;
 17900  24 
 
 17901  1148 
         SparqlParser.builtInCall_return builtInCall376 =null;
 17902  24 
 
 17903  1148 
         SparqlParser.iriRefOrFunction_return iriRefOrFunction377 =null;
 17904   
 
 17905  1148 
         SparqlParser.rdfLiteral_return rdfLiteral378 =null;
 17906   
 
 17907  1148 
         SparqlParser.numericLiteral_return numericLiteral379 =null;
 17908   
 
 17909  1148 
         SparqlParser.booleanLiteral_return booleanLiteral380 =null;
 17910   
 
 17911  1148 
         SparqlParser.var_return var381 =null;
 17912   
 
 17913  1148 
         SparqlParser.aggregate_return aggregate382 =null;
 17914   
 
 17915   
 
 17916   
 
 17917   
         try {
 17918   
             // com\\googlecode\\sparkleg\\Sparql.g:532:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 17919  1148 
             int alt125=8;
 17920  1148 
             switch ( input.LA(1) ) {
 17921   
             case OPEN_BRACE:
 17922   
                 {
 17923  24 
                 alt125=1;
 17924   
                 }
 17925  24 
                 break;
 17926   
             case ABS:
 17927   
             case BNODE:
 17928   
             case BOUND:
 17929   
             case CEIL:
 17930   
             case COALESCE:
 17931   
             case CONCAT:
 17932   
             case CONTAINS:
 17933   
             case DATATYPE:
 17934   
             case DAY:
 17935   
             case ENCODE_FOR_URI:
 17936   
             case EXISTS:
 17937   
             case FLOOR:
 17938   
             case HOURS:
 17939   
             case IF:
 17940   
             case IRI:
 17941   
             case ISBLANK:
 17942   
             case ISIRI:
 17943   
             case ISLITERAL:
 17944   
             case ISNUMERIC:
 17945   
             case ISURI:
 17946   
             case LANG:
 17947   
             case LANGMATCHES:
 17948   
             case LCASE:
 17949   
             case MD5:
 17950   
             case MINUTES:
 17951   
             case MONTH:
 17952   
             case NOT:
 17953   
             case NOW:
 17954   
             case RAND:
 17955   
             case REGEX:
 17956   
             case REPLACE:
 17957  187 
             case ROUND:
 17958   
             case SAMETERM:
 17959  187 
             case SECONDS:
 17960   
             case SHA1:
 17961   
             case SHA224:
 17962   
             case SHA256:
 17963   
             case SHA384:
 17964  89 
             case SHA512:
 17965   
             case STR:
 17966  89 
             case STRAFTER:
 17967   
             case STRBEFORE:
 17968   
             case STRDT:
 17969   
             case STRENDS:
 17970   
             case STRLANG:
 17971   
             case STRLEN:
 17972  104 
             case STRSTARTS:
 17973   
             case SUBSTR:
 17974  104 
             case TIMEZONE:
 17975   
             case TZ:
 17976   
             case UCASE:
 17977   
             case URI:
 17978   
             case YEAR:
 17979   
                 {
 17980  187 
                 alt125=2;
 17981   
                 }
 17982  187 
                 break;
 17983   
             case IRI_REF:
 17984   
             case PNAME_LN:
 17985  93 
             case PNAME_NS:
 17986   
                 {
 17987  182 
                 alt125=3;
 17988   
                 }
 17989  89 
                 break;
 17990   
             case STRING_LITERAL1:
 17991  6 
             case STRING_LITERAL2:
 17992   
             case STRING_LITERAL_LONG1:
 17993  6 
             case STRING_LITERAL_LONG2:
 17994   
                 {
 17995  104 
                 alt125=4;
 17996   
                 }
 17997  696 
                 break;
 17998   
             case DECIMAL:
 17999  592 
             case DECIMAL_NEGATIVE:
 18000   
             case DECIMAL_POSITIVE:
 18001   
             case DOUBLE:
 18002   
             case DOUBLE_NEGATIVE:
 18003   
             case DOUBLE_POSITIVE:
 18004   
             case INTEGER:
 18005   
             case INTEGER_NEGATIVE:
 18006   
             case INTEGER_POSITIVE:
 18007   
                 {
 18008  146 
                 alt125=5;
 18009   
                 }
 18010  146 
                 break;
 18011   
             case FALSE:
 18012   
             case TRUE:
 18013   
                 {
 18014  6 
                 alt125=6;
 18015   
                 }
 18016  6 
                 break;
 18017   
             case VAR1:
 18018   
             case VAR2:
 18019  1148 
                 {
 18020  592 
                 alt125=7;
 18021   
                 }
 18022  592 
                 break;
 18023  24 
             case AVG:
 18024   
             case COUNT:
 18025   
             case GROUP_CONCAT:
 18026  24 
             case MAX:
 18027  24 
             case MIN:
 18028   
             case SAMPLE:
 18029  24 
             case SUM:
 18030   
                 {
 18031  77 
                 alt125=8;
 18032   
                 }
 18033  53 
                 break;
 18034  24 
             default:
 18035  0 
                 NoViableAltException nvae =
 18036   
                     new NoViableAltException("", 125, 0, input);
 18037   
 
 18038  187 
                 throw nvae;
 18039   
 
 18040   
             }
 18041  187 
 
 18042  1335 
             switch (alt125) {
 18043   
                 case 1 :
 18044  187 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:7: brackettedExpression
 18045   
                     {
 18046  211 
                     root_0 = (Object)adaptor.nil();
 18047   
 
 18048   
 
 18049  211 
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression4934);
 18050  24 
                     brackettedExpression375=brackettedExpression();
 18051   
 
 18052  24 
                     state._fsp--;
 18053  89 
 
 18054  24 
                     adaptor.addChild(root_0, brackettedExpression375.getTree());
 18055   
 
 18056  89 
                     }
 18057  113 
                     break;
 18058   
                 case 2 :
 18059  89 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:30: builtInCall
 18060   
                     {
 18061  276 
                     root_0 = (Object)adaptor.nil();
 18062   
 
 18063   
 
 18064  276 
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression4938);
 18065  187 
                     builtInCall376=builtInCall();
 18066   
 
 18067  187 
                     state._fsp--;
 18068  104 
 
 18069  187 
                     adaptor.addChild(root_0, builtInCall376.getTree());
 18070   
 
 18071  104 
                     }
 18072  291 
                     break;
 18073   
                 case 3 :
 18074  104 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:44: iriRefOrFunction
 18075   
                     {
 18076  193 
                     root_0 = (Object)adaptor.nil();
 18077   
 
 18078   
 
 18079  193 
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression4942);
 18080  89 
                     iriRefOrFunction377=iriRefOrFunction();
 18081   
 
 18082  89 
                     state._fsp--;
 18083  93 
 
 18084  89 
                     adaptor.addChild(root_0, iriRefOrFunction377.getTree());
 18085   
 
 18086  93 
                     }
 18087  182 
                     break;
 18088   
                 case 4 :
 18089  93 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:63: rdfLiteral
 18090   
                     {
 18091  197 
                     root_0 = (Object)adaptor.nil();
 18092   
 
 18093   
 
 18094  197 
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression4946);
 18095  104 
                     rdfLiteral378=rdfLiteral();
 18096   
 
 18097  104 
                     state._fsp--;
 18098  6 
 
 18099  104 
                     adaptor.addChild(root_0, rdfLiteral378.getTree());
 18100   
 
 18101  6 
                     }
 18102  110 
                     break;
 18103   
                 case 5 :
 18104  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:76: numericLiteral
 18105   
                     {
 18106  99 
                     root_0 = (Object)adaptor.nil();
 18107   
 
 18108   
 
 18109  99 
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression4950);
 18110  93 
                     numericLiteral379=numericLiteral();
 18111   
 
 18112  93 
                     state._fsp--;
 18113  592 
 
 18114  93 
                     adaptor.addChild(root_0, numericLiteral379.getTree());
 18115   
 
 18116  592 
                     }
 18117  685 
                     break;
 18118   
                 case 6 :
 18119  592 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:93: booleanLiteral
 18120   
                     {
 18121  598 
                     root_0 = (Object)adaptor.nil();
 18122   
 
 18123   
 
 18124  598 
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression4954);
 18125  6 
                     booleanLiteral380=booleanLiteral();
 18126   
 
 18127  6 
                     state._fsp--;
 18128  53 
 
 18129  6 
                     adaptor.addChild(root_0, booleanLiteral380.getTree());
 18130   
 
 18131  53 
                     }
 18132  59 
                     break;
 18133   
                 case 7 :
 18134  53 
                     // com\\googlecode\\sparkleg\\Sparql.g:532:110: var
 18135   
                     {
 18136  645 
                     root_0 = (Object)adaptor.nil();
 18137   
 
 18138   
 
 18139  592 
                     pushFollow(FOLLOW_var_in_primaryExpression4958);
 18140  592 
                     var381=var();
 18141   
 
 18142  1740 
                     state._fsp--;
 18143   
 
 18144  592 
                     adaptor.addChild(root_0, var381.getTree());
 18145  1148 
 
 18146  1148 
                     }
 18147  592 
                     break;
 18148   
                 case 8 :
 18149   
                     // com\\googlecode\\sparkleg\\Sparql.g:532:116: aggregate
 18150   
                     {
 18151  53 
                     root_0 = (Object)adaptor.nil();
 18152   
 
 18153   
 
 18154  53 
                     pushFollow(FOLLOW_aggregate_in_primaryExpression4962);
 18155  53 
                     aggregate382=aggregate();
 18156   
 
 18157  53 
                     state._fsp--;
 18158  1148 
 
 18159  1201 
                     adaptor.addChild(root_0, aggregate382.getTree());
 18160   
 
 18161   
                     }
 18162   
                     break;
 18163   
 
 18164  273 
             }
 18165  1148 
             retval.stop = input.LT(-1);
 18166  273 
 
 18167   
 
 18168  1148 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18169  1148 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18170   
 
 18171   
         }
 18172  0 
         catch (RecognitionException re) {
 18173  273 
             reportError(re);
 18174  273 
             recover(input,re);
 18175  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18176   
 
 18177  273 
         }
 18178   
 
 18179  273 
         finally {
 18180  273 
                 // do for sure before leaving
 18181  1421 
         }
 18182  1148 
         return retval;
 18183   
     }
 18184  273 
     // $ANTLR end "primaryExpression"
 18185  273 
 
 18186  273 
 
 18187  273 
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18188  273 
         Object tree;
 18189  273 
         public Object getTree() { return tree; }
 18190   
     };
 18191   
 
 18192   
 
 18193  273 
     // $ANTLR start "brackettedExpression"
 18194  273 
     // com\\googlecode\\sparkleg\\Sparql.g:535:1: brackettedExpression : OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) ;
 18195   
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18196  273 
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18197  546 
         retval.start = input.LT(1);
 18198  273 
 
 18199   
 
 18200  546 
         Object root_0 = null;
 18201   
 
 18202  546 
         Token OPEN_BRACE383=null;
 18203  273 
         Token CLOSE_BRACE385=null;
 18204  546 
         SparqlParser.expression_return expression384 =null;
 18205  273 
 
 18206   
 
 18207  273 
         Object OPEN_BRACE383_tree=null;
 18208  273 
         Object CLOSE_BRACE385_tree=null;
 18209  273 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18210  273 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18211  273 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18212   
         try {
 18213   
             // com\\googlecode\\sparkleg\\Sparql.g:536:5: ( OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) )
 18214   
             // com\\googlecode\\sparkleg\\Sparql.g:536:7: OPEN_BRACE expression CLOSE_BRACE
 18215  273 
             {
 18216  546 
             OPEN_BRACE383=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_brackettedExpression4979);
 18217  273 
             stream_OPEN_BRACE.add(OPEN_BRACE383);
 18218  273 
 
 18219   
 
 18220  273 
             pushFollow(FOLLOW_expression_in_brackettedExpression4981);
 18221  273 
             expression384=expression();
 18222   
 
 18223  546 
             state._fsp--;
 18224  273 
 
 18225  273 
             stream_expression.add(expression384.getTree());
 18226   
 
 18227  273 
             CLOSE_BRACE385=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_brackettedExpression4983);
 18228  546 
             stream_CLOSE_BRACE.add(CLOSE_BRACE385);
 18229   
 
 18230  273 
 
 18231   
             // AST REWRITE
 18232   
             // elements: expression
 18233   
             // token labels:
 18234   
             // rule labels: retval
 18235   
             // token list labels:
 18236  273 
             // rule list labels:
 18237   
             // wildcard labels:
 18238  273 
             retval.tree = root_0;
 18239  273 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18240  273 
 
 18241  273 
             root_0 = (Object)adaptor.nil();
 18242   
             // 536:41: -> ^( BRACKETTED_EXPRESSION expression )
 18243  273 
             {
 18244  273 
                 // com\\googlecode\\sparkleg\\Sparql.g:536:44: ^( BRACKETTED_EXPRESSION expression )
 18245   
                 {
 18246  273 
                 Object root_1 = (Object)adaptor.nil();
 18247  273 
                 root_1 = (Object)adaptor.becomeRoot(
 18248   
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18249   
                 , root_1);
 18250   
 
 18251  273 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18252   
 
 18253  273 
                 adaptor.addChild(root_0, root_1);
 18254   
                 }
 18255   
 
 18256  273 
             }
 18257  273 
 
 18258   
 
 18259  273 
             retval.tree = root_0;
 18260   
 
 18261   
             }
 18262  266 
 
 18263  273 
             retval.stop = input.LT(-1);
 18264  266 
 
 18265   
 
 18266  273 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18267  273 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18268   
 
 18269   
         }
 18270  0 
         catch (RecognitionException re) {
 18271  266 
             reportError(re);
 18272  266 
             recover(input,re);
 18273  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18274   
 
 18275  266 
         }
 18276   
 
 18277  266 
         finally {
 18278  266 
                 // do for sure before leaving
 18279  539 
         }
 18280  539 
         return retval;
 18281  266 
     }
 18282  266 
     // $ANTLR end "brackettedExpression"
 18283  266 
 
 18284  266 
 
 18285  266 
     public static class builtInCall_return extends ParserRuleReturnScope {
 18286  266 
         Object tree;
 18287  266 
         public Object getTree() { return tree; }
 18288  266 
     };
 18289  266 
 
 18290  266 
 
 18291  266 
     // $ANTLR start "builtInCall"
 18292  266 
     // com\\googlecode\\sparkleg\\Sparql.g:539:1: builtInCall : ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18293  266 
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18294  532 
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18295  532 
         retval.start = input.LT(1);
 18296  266 
 
 18297  266 
 
 18298  532 
         Object root_0 = null;
 18299  266 
 
 18300  532 
         Token STR386=null;
 18301  532 
         Token OPEN_BRACE387=null;
 18302  532 
         Token CLOSE_BRACE389=null;
 18303  532 
         Token LANG390=null;
 18304  532 
         Token OPEN_BRACE391=null;
 18305  532 
         Token CLOSE_BRACE393=null;
 18306  532 
         Token LANGMATCHES394=null;
 18307  532 
         Token OPEN_BRACE395=null;
 18308  532 
         Token COMMA397=null;
 18309  532 
         Token CLOSE_BRACE399=null;
 18310  532 
         Token DATATYPE400=null;
 18311  532 
         Token OPEN_BRACE401=null;
 18312  532 
         Token CLOSE_BRACE403=null;
 18313  532 
         Token BOUND404=null;
 18314  532 
         Token OPEN_BRACE405=null;
 18315  532 
         Token CLOSE_BRACE407=null;
 18316  532 
         Token IRI408=null;
 18317  532 
         Token OPEN_BRACE409=null;
 18318  532 
         Token CLOSE_BRACE411=null;
 18319  532 
         Token URI412=null;
 18320  532 
         Token OPEN_BRACE413=null;
 18321  532 
         Token CLOSE_BRACE415=null;
 18322  532 
         Token BNODE416=null;
 18323  532 
         Token OPEN_BRACE417=null;
 18324  532 
         Token CLOSE_BRACE419=null;
 18325  532 
         Token BNODE420=null;
 18326  532 
         Token RAND422=null;
 18327  532 
         Token ABS424=null;
 18328  532 
         Token OPEN_BRACE425=null;
 18329  532 
         Token CLOSE_BRACE427=null;
 18330  532 
         Token CEIL428=null;
 18331  532 
         Token OPEN_BRACE429=null;
 18332  532 
         Token CLOSE_BRACE431=null;
 18333  532 
         Token FLOOR432=null;
 18334  532 
         Token OPEN_BRACE433=null;
 18335  532 
         Token CLOSE_BRACE435=null;
 18336  532 
         Token ROUND436=null;
 18337  532 
         Token OPEN_BRACE437=null;
 18338  532 
         Token CLOSE_BRACE439=null;
 18339  532 
         Token CONCAT440=null;
 18340  532 
         Token STRLEN443=null;
 18341  532 
         Token OPEN_BRACE444=null;
 18342  532 
         Token CLOSE_BRACE446=null;
 18343  532 
         Token UCASE447=null;
 18344  532 
         Token OPEN_BRACE448=null;
 18345  532 
         Token CLOSE_BRACE450=null;
 18346  532 
         Token LCASE451=null;
 18347  532 
         Token OPEN_BRACE452=null;
 18348  532 
         Token CLOSE_BRACE454=null;
 18349  532 
         Token ENCODE_FOR_URI455=null;
 18350  532 
         Token OPEN_BRACE456=null;
 18351  532 
         Token CLOSE_BRACE458=null;
 18352  532 
         Token CONTAINS459=null;
 18353  532 
         Token OPEN_BRACE460=null;
 18354  532 
         Token COMMA462=null;
 18355  532 
         Token CLOSE_BRACE464=null;
 18356  532 
         Token STRSTARTS465=null;
 18357  532 
         Token OPEN_BRACE466=null;
 18358  532 
         Token COMMA468=null;
 18359  532 
         Token CLOSE_BRACE470=null;
 18360  532 
         Token STRENDS471=null;
 18361  532 
         Token OPEN_BRACE472=null;
 18362  532 
         Token COMMA474=null;
 18363  532 
         Token CLOSE_BRACE476=null;
 18364  532 
         Token STRBEFORE477=null;
 18365  532 
         Token OPEN_BRACE478=null;
 18366  532 
         Token COMMA480=null;
 18367  532 
         Token CLOSE_BRACE482=null;
 18368  532 
         Token STRAFTER483=null;
 18369  532 
         Token OPEN_BRACE484=null;
 18370  532 
         Token COMMA486=null;
 18371  532 
         Token CLOSE_BRACE488=null;
 18372  532 
         Token REPLACE489=null;
 18373  532 
         Token OPEN_BRACE490=null;
 18374  532 
         Token COMMA492=null;
 18375  532 
         Token COMMA494=null;
 18376  532 
         Token CLOSE_BRACE496=null;
 18377  532 
         Token YEAR497=null;
 18378  532 
         Token OPEN_BRACE498=null;
 18379  532 
         Token CLOSE_BRACE500=null;
 18380  532 
         Token MONTH501=null;
 18381  532 
         Token OPEN_BRACE502=null;
 18382  532 
         Token CLOSE_BRACE504=null;
 18383  532 
         Token DAY505=null;
 18384  532 
         Token OPEN_BRACE506=null;
 18385  532 
         Token CLOSE_BRACE508=null;
 18386  532 
         Token HOURS509=null;
 18387  532 
         Token OPEN_BRACE510=null;
 18388  532 
         Token CLOSE_BRACE512=null;
 18389  532 
         Token MINUTES513=null;
 18390  532 
         Token OPEN_BRACE514=null;
 18391  532 
         Token CLOSE_BRACE516=null;
 18392  532 
         Token SECONDS517=null;
 18393  532 
         Token OPEN_BRACE518=null;
 18394  532 
         Token CLOSE_BRACE520=null;
 18395  532 
         Token TIMEZONE521=null;
 18396  532 
         Token OPEN_BRACE522=null;
 18397  532 
         Token CLOSE_BRACE524=null;
 18398  532 
         Token TZ525=null;
 18399  532 
         Token OPEN_BRACE526=null;
 18400  532 
         Token CLOSE_BRACE528=null;
 18401  532 
         Token NOW529=null;
 18402  532 
         Token MD5531=null;
 18403  532 
         Token OPEN_BRACE532=null;
 18404  532 
         Token CLOSE_BRACE534=null;
 18405  532 
         Token SHA1535=null;
 18406  532 
         Token OPEN_BRACE536=null;
 18407  532 
         Token CLOSE_BRACE538=null;
 18408  532 
         Token SHA224539=null;
 18409  532 
         Token OPEN_BRACE540=null;
 18410  532 
         Token CLOSE_BRACE542=null;
 18411  532 
         Token SHA256543=null;
 18412  532 
         Token OPEN_BRACE544=null;
 18413  532 
         Token CLOSE_BRACE546=null;
 18414  532 
         Token SHA384547=null;
 18415  532 
         Token OPEN_BRACE548=null;
 18416  532 
         Token CLOSE_BRACE550=null;
 18417  532 
         Token SHA512551=null;
 18418  532 
         Token OPEN_BRACE552=null;
 18419  532 
         Token CLOSE_BRACE554=null;
 18420  532 
         Token COALESCE555=null;
 18421  532 
         Token IF557=null;
 18422  532 
         Token OPEN_BRACE558=null;
 18423  532 
         Token COMMA559=null;
 18424  532 
         Token COMMA560=null;
 18425  532 
         Token CLOSE_BRACE561=null;
 18426  532 
         Token STRLANG562=null;
 18427  532 
         Token OPEN_BRACE563=null;
 18428  532 
         Token COMMA565=null;
 18429  532 
         Token CLOSE_BRACE567=null;
 18430  532 
         Token STRDT568=null;
 18431  266 
         Token OPEN_BRACE569=null;
 18432  532 
         Token COMMA571=null;
 18433  266 
         Token CLOSE_BRACE573=null;
 18434  532 
         Token SAMETERM574=null;
 18435  266 
         Token OPEN_BRACE575=null;
 18436  532 
         Token COMMA577=null;
 18437  266 
         Token CLOSE_BRACE579=null;
 18438  532 
         Token ISIRI580=null;
 18439  266 
         Token OPEN_BRACE581=null;
 18440  532 
         Token CLOSE_BRACE583=null;
 18441  266 
         Token ISURI584=null;
 18442  532 
         Token OPEN_BRACE585=null;
 18443  266 
         Token CLOSE_BRACE587=null;
 18444  532 
         Token ISBLANK588=null;
 18445  266 
         Token OPEN_BRACE589=null;
 18446  532 
         Token CLOSE_BRACE591=null;
 18447  266 
         Token ISLITERAL592=null;
 18448  532 
         Token OPEN_BRACE593=null;
 18449  266 
         Token CLOSE_BRACE595=null;
 18450  532 
         Token ISNUMERIC596=null;
 18451  266 
         Token OPEN_BRACE597=null;
 18452  532 
         Token CLOSE_BRACE599=null;
 18453  266 
         SparqlParser.expression_return e1 =null;
 18454  266 
 
 18455  266 
         SparqlParser.expression_return e2 =null;
 18456  266 
 
 18457  266 
         SparqlParser.expression_return e3 =null;
 18458  266 
 
 18459  266 
         SparqlParser.expression_return expression388 =null;
 18460  266 
 
 18461  266 
         SparqlParser.expression_return expression392 =null;
 18462  266 
 
 18463  266 
         SparqlParser.expression_return expression396 =null;
 18464  266 
 
 18465  266 
         SparqlParser.expression_return expression398 =null;
 18466  266 
 
 18467  266 
         SparqlParser.expression_return expression402 =null;
 18468  266 
 
 18469  266 
         SparqlParser.var_return var406 =null;
 18470  266 
 
 18471  266 
         SparqlParser.expression_return expression410 =null;
 18472  266 
 
 18473  266 
         SparqlParser.expression_return expression414 =null;
 18474  266 
 
 18475  266 
         SparqlParser.expression_return expression418 =null;
 18476  266 
 
 18477  266 
         SparqlParser.nil_return nil421 =null;
 18478  266 
 
 18479  266 
         SparqlParser.nil_return nil423 =null;
 18480  266 
 
 18481  266 
         SparqlParser.expression_return expression426 =null;
 18482  266 
 
 18483  266 
         SparqlParser.expression_return expression430 =null;
 18484  266 
 
 18485  266 
         SparqlParser.expression_return expression434 =null;
 18486  266 
 
 18487  266 
         SparqlParser.expression_return expression438 =null;
 18488  266 
 
 18489  266 
         SparqlParser.expressionList_return expressionList441 =null;
 18490  266 
 
 18491  266 
         SparqlParser.subStringExpression_return subStringExpression442 =null;
 18492  266 
 
 18493  266 
         SparqlParser.expression_return expression445 =null;
 18494  266 
 
 18495  266 
         SparqlParser.expression_return expression449 =null;
 18496  266 
 
 18497  266 
         SparqlParser.expression_return expression453 =null;
 18498  266 
 
 18499  266 
         SparqlParser.expression_return expression457 =null;
 18500  266 
 
 18501  266 
         SparqlParser.expression_return expression461 =null;
 18502  266 
 
 18503  266 
         SparqlParser.expression_return expression463 =null;
 18504  266 
 
 18505  266 
         SparqlParser.expression_return expression467 =null;
 18506  266 
 
 18507  266 
         SparqlParser.expression_return expression469 =null;
 18508  266 
 
 18509  266 
         SparqlParser.expression_return expression473 =null;
 18510  266 
 
 18511  266 
         SparqlParser.expression_return expression475 =null;
 18512  266 
 
 18513  266 
         SparqlParser.expression_return expression479 =null;
 18514  266 
 
 18515  266 
         SparqlParser.expression_return expression481 =null;
 18516  266 
 
 18517  266 
         SparqlParser.expression_return expression485 =null;
 18518  266 
 
 18519  266 
         SparqlParser.expression_return expression487 =null;
 18520  266 
 
 18521  266 
         SparqlParser.expression_return expression491 =null;
 18522  266 
 
 18523  266 
         SparqlParser.expression_return expression493 =null;
 18524  266 
 
 18525  266 
         SparqlParser.expression_return expression495 =null;
 18526  266 
 
 18527  266 
         SparqlParser.expression_return expression499 =null;
 18528  266 
 
 18529  266 
         SparqlParser.expression_return expression503 =null;
 18530  266 
 
 18531  266 
         SparqlParser.expression_return expression507 =null;
 18532  266 
 
 18533  266 
         SparqlParser.expression_return expression511 =null;
 18534  266 
 
 18535  266 
         SparqlParser.expression_return expression515 =null;
 18536  266 
 
 18537  266 
         SparqlParser.expression_return expression519 =null;
 18538  266 
 
 18539  266 
         SparqlParser.expression_return expression523 =null;
 18540  266 
 
 18541  266 
         SparqlParser.expression_return expression527 =null;
 18542  266 
 
 18543  266 
         SparqlParser.nil_return nil530 =null;
 18544  266 
 
 18545  266 
         SparqlParser.expression_return expression533 =null;
 18546  266 
 
 18547  266 
         SparqlParser.expression_return expression537 =null;
 18548  266 
 
 18549  266 
         SparqlParser.expression_return expression541 =null;
 18550  266 
 
 18551  266 
         SparqlParser.expression_return expression545 =null;
 18552  266 
 
 18553  266 
         SparqlParser.expression_return expression549 =null;
 18554  266 
 
 18555  266 
         SparqlParser.expression_return expression553 =null;
 18556  266 
 
 18557  266 
         SparqlParser.expressionList_return expressionList556 =null;
 18558  266 
 
 18559  266 
         SparqlParser.expression_return expression564 =null;
 18560  266 
 
 18561  266 
         SparqlParser.expression_return expression566 =null;
 18562  266 
 
 18563  266 
         SparqlParser.expression_return expression570 =null;
 18564   
 
 18565  532 
         SparqlParser.expression_return expression572 =null;
 18566  266 
 
 18567  532 
         SparqlParser.expression_return expression576 =null;
 18568  266 
 
 18569  532 
         SparqlParser.expression_return expression578 =null;
 18570  266 
 
 18571  532 
         SparqlParser.expression_return expression582 =null;
 18572  266 
 
 18573  532 
         SparqlParser.expression_return expression586 =null;
 18574  266 
 
 18575  532 
         SparqlParser.expression_return expression590 =null;
 18576  266 
 
 18577  532 
         SparqlParser.expression_return expression594 =null;
 18578  266 
 
 18579  532 
         SparqlParser.expression_return expression598 =null;
 18580  266 
 
 18581  532 
         SparqlParser.regexExpression_return regexExpression600 =null;
 18582  266 
 
 18583  532 
         SparqlParser.existsFunction_return existsFunction601 =null;
 18584  266 
 
 18585  532 
         SparqlParser.notExistsFunction_return notExistsFunction602 =null;
 18586  266 
 
 18587  266 
 
 18588  532 
         Object STR386_tree=null;
 18589  532 
         Object OPEN_BRACE387_tree=null;
 18590  532 
         Object CLOSE_BRACE389_tree=null;
 18591  532 
         Object LANG390_tree=null;
 18592  532 
         Object OPEN_BRACE391_tree=null;
 18593  532 
         Object CLOSE_BRACE393_tree=null;
 18594  532 
         Object LANGMATCHES394_tree=null;
 18595  532 
         Object OPEN_BRACE395_tree=null;
 18596  532 
         Object COMMA397_tree=null;
 18597  532 
         Object CLOSE_BRACE399_tree=null;
 18598  532 
         Object DATATYPE400_tree=null;
 18599  532 
         Object OPEN_BRACE401_tree=null;
 18600  532 
         Object CLOSE_BRACE403_tree=null;
 18601  532 
         Object BOUND404_tree=null;
 18602  532 
         Object OPEN_BRACE405_tree=null;
 18603  532 
         Object CLOSE_BRACE407_tree=null;
 18604  532 
         Object IRI408_tree=null;
 18605  532 
         Object OPEN_BRACE409_tree=null;
 18606  532 
         Object CLOSE_BRACE411_tree=null;
 18607  532 
         Object URI412_tree=null;
 18608  532 
         Object OPEN_BRACE413_tree=null;
 18609  532 
         Object CLOSE_BRACE415_tree=null;
 18610  532 
         Object BNODE416_tree=null;
 18611  532 
         Object OPEN_BRACE417_tree=null;
 18612  532 
         Object CLOSE_BRACE419_tree=null;
 18613  532 
         Object BNODE420_tree=null;
 18614  532 
         Object RAND422_tree=null;
 18615  532 
         Object ABS424_tree=null;
 18616  532 
         Object OPEN_BRACE425_tree=null;
 18617  532 
         Object CLOSE_BRACE427_tree=null;
 18618  532 
         Object CEIL428_tree=null;
 18619  532 
         Object OPEN_BRACE429_tree=null;
 18620  532 
         Object CLOSE_BRACE431_tree=null;
 18621  532 
         Object FLOOR432_tree=null;
 18622  532 
         Object OPEN_BRACE433_tree=null;
 18623  532 
         Object CLOSE_BRACE435_tree=null;
 18624  532 
         Object ROUND436_tree=null;
 18625  532 
         Object OPEN_BRACE437_tree=null;
 18626  532 
         Object CLOSE_BRACE439_tree=null;
 18627  532 
         Object CONCAT440_tree=null;
 18628  532 
         Object STRLEN443_tree=null;
 18629  532 
         Object OPEN_BRACE444_tree=null;
 18630  532 
         Object CLOSE_BRACE446_tree=null;
 18631  532 
         Object UCASE447_tree=null;
 18632  532 
         Object OPEN_BRACE448_tree=null;
 18633  532 
         Object CLOSE_BRACE450_tree=null;
 18634  532 
         Object LCASE451_tree=null;
 18635  532 
         Object OPEN_BRACE452_tree=null;
 18636  532 
         Object CLOSE_BRACE454_tree=null;
 18637  532 
         Object ENCODE_FOR_URI455_tree=null;
 18638  532 
         Object OPEN_BRACE456_tree=null;
 18639  532 
         Object CLOSE_BRACE458_tree=null;
 18640  532 
         Object CONTAINS459_tree=null;
 18641  532 
         Object OPEN_BRACE460_tree=null;
 18642  532 
         Object COMMA462_tree=null;
 18643  532 
         Object CLOSE_BRACE464_tree=null;
 18644  532 
         Object STRSTARTS465_tree=null;
 18645  532 
         Object OPEN_BRACE466_tree=null;
 18646  532 
         Object COMMA468_tree=null;
 18647  532 
         Object CLOSE_BRACE470_tree=null;
 18648  532 
         Object STRENDS471_tree=null;
 18649  532 
         Object OPEN_BRACE472_tree=null;
 18650  532 
         Object COMMA474_tree=null;
 18651  532 
         Object CLOSE_BRACE476_tree=null;
 18652  532 
         Object STRBEFORE477_tree=null;
 18653  532 
         Object OPEN_BRACE478_tree=null;
 18654  532 
         Object COMMA480_tree=null;
 18655  532 
         Object CLOSE_BRACE482_tree=null;
 18656  532 
         Object STRAFTER483_tree=null;
 18657  532 
         Object OPEN_BRACE484_tree=null;
 18658  532 
         Object COMMA486_tree=null;
 18659  532 
         Object CLOSE_BRACE488_tree=null;
 18660  532 
         Object REPLACE489_tree=null;
 18661  532 
         Object OPEN_BRACE490_tree=null;
 18662  532 
         Object COMMA492_tree=null;
 18663  532 
         Object COMMA494_tree=null;
 18664  532 
         Object CLOSE_BRACE496_tree=null;
 18665  532 
         Object YEAR497_tree=null;
 18666  532 
         Object OPEN_BRACE498_tree=null;
 18667  532 
         Object CLOSE_BRACE500_tree=null;
 18668  532 
         Object MONTH501_tree=null;
 18669  532 
         Object OPEN_BRACE502_tree=null;
 18670  532 
         Object CLOSE_BRACE504_tree=null;
 18671  532 
         Object DAY505_tree=null;
 18672  532 
         Object OPEN_BRACE506_tree=null;
 18673  532 
         Object CLOSE_BRACE508_tree=null;
 18674  532 
         Object HOURS509_tree=null;
 18675  532 
         Object OPEN_BRACE510_tree=null;
 18676  532 
         Object CLOSE_BRACE512_tree=null;
 18677  532 
         Object MINUTES513_tree=null;
 18678  532 
         Object OPEN_BRACE514_tree=null;
 18679  532 
         Object CLOSE_BRACE516_tree=null;
 18680  532 
         Object SECONDS517_tree=null;
 18681  532 
         Object OPEN_BRACE518_tree=null;
 18682  532 
         Object CLOSE_BRACE520_tree=null;
 18683  532 
         Object TIMEZONE521_tree=null;
 18684  532 
         Object OPEN_BRACE522_tree=null;
 18685  532 
         Object CLOSE_BRACE524_tree=null;
 18686  532 
         Object TZ525_tree=null;
 18687  532 
         Object OPEN_BRACE526_tree=null;
 18688  532 
         Object CLOSE_BRACE528_tree=null;
 18689  532 
         Object NOW529_tree=null;
 18690  532 
         Object MD5531_tree=null;
 18691  532 
         Object OPEN_BRACE532_tree=null;
 18692  532 
         Object CLOSE_BRACE534_tree=null;
 18693  532 
         Object SHA1535_tree=null;
 18694  532 
         Object OPEN_BRACE536_tree=null;
 18695  532 
         Object CLOSE_BRACE538_tree=null;
 18696  532 
         Object SHA224539_tree=null;
 18697  532 
         Object OPEN_BRACE540_tree=null;
 18698  532 
         Object CLOSE_BRACE542_tree=null;
 18699  532 
         Object SHA256543_tree=null;
 18700  532 
         Object OPEN_BRACE544_tree=null;
 18701  532 
         Object CLOSE_BRACE546_tree=null;
 18702  532 
         Object SHA384547_tree=null;
 18703  532 
         Object OPEN_BRACE548_tree=null;
 18704  532 
         Object CLOSE_BRACE550_tree=null;
 18705  532 
         Object SHA512551_tree=null;
 18706  532 
         Object OPEN_BRACE552_tree=null;
 18707  532 
         Object CLOSE_BRACE554_tree=null;
 18708  532 
         Object COALESCE555_tree=null;
 18709  532 
         Object IF557_tree=null;
 18710  532 
         Object OPEN_BRACE558_tree=null;
 18711  532 
         Object COMMA559_tree=null;
 18712  532 
         Object COMMA560_tree=null;
 18713  532 
         Object CLOSE_BRACE561_tree=null;
 18714  532 
         Object STRLANG562_tree=null;
 18715  532 
         Object OPEN_BRACE563_tree=null;
 18716  532 
         Object COMMA565_tree=null;
 18717  532 
         Object CLOSE_BRACE567_tree=null;
 18718  532 
         Object STRDT568_tree=null;
 18719  532 
         Object OPEN_BRACE569_tree=null;
 18720  532 
         Object COMMA571_tree=null;
 18721  532 
         Object CLOSE_BRACE573_tree=null;
 18722  532 
         Object SAMETERM574_tree=null;
 18723  532 
         Object OPEN_BRACE575_tree=null;
 18724  532 
         Object COMMA577_tree=null;
 18725  532 
         Object CLOSE_BRACE579_tree=null;
 18726  532 
         Object ISIRI580_tree=null;
 18727  532 
         Object OPEN_BRACE581_tree=null;
 18728  532 
         Object CLOSE_BRACE583_tree=null;
 18729  532 
         Object ISURI584_tree=null;
 18730  532 
         Object OPEN_BRACE585_tree=null;
 18731  532 
         Object CLOSE_BRACE587_tree=null;
 18732  532 
         Object ISBLANK588_tree=null;
 18733  532 
         Object OPEN_BRACE589_tree=null;
 18734  532 
         Object CLOSE_BRACE591_tree=null;
 18735  532 
         Object ISLITERAL592_tree=null;
 18736  532 
         Object OPEN_BRACE593_tree=null;
 18737  532 
         Object CLOSE_BRACE595_tree=null;
 18738  532 
         Object ISNUMERIC596_tree=null;
 18739  532 
         Object OPEN_BRACE597_tree=null;
 18740  532 
         Object CLOSE_BRACE599_tree=null;
 18741  532 
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 18742  532 
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 18743  532 
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 18744  532 
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 18745  532 
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 18746  532 
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 18747  532 
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 18748  532 
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 18749  532 
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 18750  532 
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 18751  532 
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 18752  532 
         RewriteRuleTokenStream stream_SHA224=new RewriteRuleTokenStream(adaptor,"token SHA224");
 18753  532 
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 18754  532 
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 18755  532 
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 18756  532 
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 18757  532 
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 18758  532 
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 18759  532 
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 18760  532 
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 18761  532 
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 18762  532 
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 18763  532 
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 18764  532 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 18765  532 
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 18766  532 
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 18767  532 
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 18768  532 
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 18769  532 
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 18770  532 
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 18771  532 
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 18772  532 
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 18773  532 
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 18774  532 
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 18775  532 
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 18776  532 
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 18777  532 
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 18778  266 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18779  266 
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 18780  532 
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 18781  532 
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 18782  266 
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 18783  266 
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 18784  284 
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 18785  266 
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 18786  284 
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 18787  266 
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 18788  266 
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 18789  286 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18790  266 
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 18791  286 
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 18792  266 
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 18793  266 
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 18794  281 
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 18795  266 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18796  281 
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 18797  266 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 18798  266 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 18799  316 
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 18800  266 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 18801  50 
         try {
 18802   
             // com\\googlecode\\sparkleg\\Sparql.g:540:5: ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 18803  266 
             int alt126=54;
 18804  281 
             switch ( input.LA(1) ) {
 18805   
             case STR:
 18806  15 
                 {
 18807  18 
                 alt126=1;
 18808   
                 }
 18809  19 
                 break;
 18810   
             case LANG:
 18811  1 
                 {
 18812  20 
                 alt126=2;
 18813   
                 }
 18814  21 
                 break;
 18815   
             case LANGMATCHES:
 18816  1 
                 {
 18817  15 
                 alt126=3;
 18818   
                 }
 18819  19 
                 break;
 18820   
             case DATATYPE:
 18821   
                 {
 18822  54 
                 alt126=4;
 18823   
                 }
 18824  50 
                 break;
 18825  2 
             case BOUND:
 18826   
                 {
 18827  17 
                 alt126=5;
 18828   
                 }
 18829  15 
                 break;
 18830   
             case IRI:
 18831   
                 {
 18832  1 
                 alt126=6;
 18833   
                 }
 18834  1 
                 break;
 18835   
             case URI:
 18836   
                 {
 18837  1 
                 alt126=7;
 18838   
                 }
 18839  1 
                 break;
 18840   
             case BNODE:
 18841   
                 {
 18842  4 
                 switch ( input.LA(2) ) {
 18843   
                 case OPEN_BRACE:
 18844   
                     {
 18845  4 
                     switch ( input.LA(3) ) {
 18846   
                     case CLOSE_BRACE:
 18847   
                         {
 18848  2 
                         alt126=9;
 18849   
                         }
 18850  2 
                         break;
 18851   
                     case ABS:
 18852   
                     case AVG:
 18853   
                     case BNODE:
 18854   
                     case BOUND:
 18855   
                     case CEIL:
 18856   
                     case COALESCE:
 18857   
                     case CONCAT:
 18858   
                     case CONTAINS:
 18859   
                     case COUNT:
 18860   
                     case DATATYPE:
 18861   
                     case DAY:
 18862   
                     case DECIMAL:
 18863   
                     case DECIMAL_NEGATIVE:
 18864   
                     case DECIMAL_POSITIVE:
 18865   
                     case DOUBLE:
 18866   
                     case DOUBLE_NEGATIVE:
 18867   
                     case DOUBLE_POSITIVE:
 18868   
                     case ENCODE_FOR_URI:
 18869   
                     case EXISTS:
 18870   
                     case FALSE:
 18871   
                     case FLOOR:
 18872   
                     case GROUP_CONCAT:
 18873   
                     case HOURS:
 18874   
                     case IF:
 18875   
                     case INTEGER:
 18876   
                     case INTEGER_NEGATIVE:
 18877   
                     case INTEGER_POSITIVE:
 18878   
                     case IRI:
 18879   
                     case IRI_REF:
 18880   
                     case ISBLANK:
 18881   
                     case ISIRI:
 18882   
                     case ISLITERAL:
 18883   
                     case ISNUMERIC:
 18884   
                     case ISURI:
 18885   
                     case LANG:
 18886   
                     case LANGMATCHES:
 18887   
                     case LCASE:
 18888   
                     case MAX:
 18889   
                     case MD5:
 18890   
                     case MIN:
 18891   
                     case MINUS:
 18892   
                     case MINUTES:
 18893   
                     case MONTH:
 18894   
                     case NEGATION:
 18895   
                     case NOT:
 18896   
                     case NOW:
 18897   
                     case OPEN_BRACE:
 18898   
                     case PLUS:
 18899   
                     case PNAME_LN:
 18900   
                     case PNAME_NS:
 18901   
                     case RAND:
 18902   
                     case REGEX:
 18903   
                     case REPLACE:
 18904   
                     case ROUND:
 18905   
                     case SAMETERM:
 18906   
                     case SAMPLE:
 18907   
                     case SECONDS:
 18908   
                     case SHA1:
 18909   
                     case SHA224:
 18910   
                     case SHA256:
 18911   
                     case SHA384:
 18912   
                     case SHA512:
 18913  2 
                     case STR:
 18914   
                     case STRAFTER:
 18915  2 
                     case STRBEFORE:
 18916   
                     case STRDT:
 18917   
                     case STRENDS:
 18918   
                     case STRING_LITERAL1:
 18919   
                     case STRING_LITERAL2:
 18920   
                     case STRING_LITERAL_LONG1:
 18921   
                     case STRING_LITERAL_LONG2:
 18922   
                     case STRLANG:
 18923   
                     case STRLEN:
 18924   
                     case STRSTARTS:
 18925  4 
                     case SUBSTR:
 18926   
                     case SUM:
 18927   
                     case TIMEZONE:
 18928   
                     case TRUE:
 18929   
                     case TZ:
 18930   
                     case UCASE:
 18931   
                     case URI:
 18932   
                     case VAR1:
 18933   
                     case VAR2:
 18934   
                     case YEAR:
 18935  4 
                         {
 18936  2 
                         alt126=8;
 18937   
                         }
 18938  3 
                         break;
 18939   
                     default:
 18940  1 
                         NoViableAltException nvae =
 18941   
                             new NoViableAltException("", 126, 54, input);
 18942   
 
 18943  1 
                         throw nvae;
 18944   
 
 18945  1 
                     }
 18946   
 
 18947   
                     }
 18948  5 
                     break;
 18949   
                 default:
 18950  1 
                     NoViableAltException nvae =
 18951   
                         new NoViableAltException("", 126, 8, input);
 18952   
 
 18953  1 
                     throw nvae;
 18954   
 
 18955  1 
                 }
 18956   
 
 18957   
                 }
 18958  5 
                 break;
 18959   
             case RAND:
 18960  1 
                 {
 18961  1 
                 alt126=10;
 18962   
                 }
 18963  6 
                 break;
 18964   
             case ABS:
 18965  5 
                 {
 18966  1 
                 alt126=11;
 18967   
                 }
 18968  3 
                 break;
 18969   
             case CEIL:
 18970  2 
                 {
 18971  1 
                 alt126=12;
 18972   
                 }
 18973  2 
                 break;
 18974   
             case FLOOR:
 18975  1 
                 {
 18976  1 
                 alt126=13;
 18977   
                 }
 18978  2 
                 break;
 18979   
             case ROUND:
 18980  1 
                 {
 18981  1 
                 alt126=14;
 18982   
                 }
 18983  2 
                 break;
 18984   
             case CONCAT:
 18985  1 
                 {
 18986  5 
                 alt126=15;
 18987   
                 }
 18988  6 
                 break;
 18989   
             case SUBSTR:
 18990  1 
                 {
 18991  2 
                 alt126=16;
 18992   
                 }
 18993  3 
                 break;
 18994   
             case STRLEN:
 18995  1 
                 {
 18996  1 
                 alt126=17;
 18997   
                 }
 18998  2 
                 break;
 18999   
             case UCASE:
 19000  1 
                 {
 19001  1 
                 alt126=18;
 19002   
                 }
 19003  2 
                 break;
 19004   
             case LCASE:
 19005  1 
                 {
 19006  1 
                 alt126=19;
 19007   
                 }
 19008  2 
                 break;
 19009   
             case ENCODE_FOR_URI:
 19010  1 
                 {
 19011  1 
                 alt126=20;
 19012   
                 }
 19013  2 
                 break;
 19014   
             case CONTAINS:
 19015  1 
                 {
 19016  1 
                 alt126=21;
 19017   
                 }
 19018  4 
                 break;
 19019   
             case STRSTARTS:
 19020  3 
                 {
 19021  1 
                 alt126=22;
 19022   
                 }
 19023  2 
                 break;
 19024   
             case STRENDS:
 19025  1 
                 {
 19026  1 
                 alt126=23;
 19027   
                 }
 19028  2 
                 break;
 19029   
             case STRBEFORE:
 19030  1 
                 {
 19031  1 
                 alt126=24;
 19032   
                 }
 19033  2 
                 break;
 19034   
             case STRAFTER:
 19035  1 
                 {
 19036  1 
                 alt126=25;
 19037   
                 }
 19038  2 
                 break;
 19039   
             case REPLACE:
 19040  1 
                 {
 19041  3 
                 alt126=26;
 19042   
                 }
 19043  4 
                 break;
 19044   
             case YEAR:
 19045  1 
                 {
 19046  1 
                 alt126=27;
 19047   
                 }
 19048  2 
                 break;
 19049   
             case MONTH:
 19050  1 
                 {
 19051  1 
                 alt126=28;
 19052   
                 }
 19053  2 
                 break;
 19054   
             case DAY:
 19055  1 
                 {
 19056  1 
                 alt126=29;
 19057   
                 }
 19058  2 
                 break;
 19059   
             case HOURS:
 19060  1 
                 {
 19061  1 
                 alt126=30;
 19062   
                 }
 19063  2 
                 break;
 19064   
             case MINUTES:
 19065  1 
                 {
 19066  1 
                 alt126=31;
 19067   
                 }
 19068  3 
                 break;
 19069   
             case SECONDS:
 19070  2 
                 {
 19071  1 
                 alt126=32;
 19072   
                 }
 19073  3 
                 break;
 19074   
             case TIMEZONE:
 19075  2 
                 {
 19076  1 
                 alt126=33;
 19077   
                 }
 19078  1 
                 break;
 19079   
             case TZ:
 19080   
                 {
 19081  1 
                 alt126=34;
 19082   
                 }
 19083  3 
                 break;
 19084   
             case NOW:
 19085  2 
                 {
 19086  1 
                 alt126=35;
 19087   
                 }
 19088  3 
                 break;
 19089   
             case MD5:
 19090  2 
                 {
 19091  2 
                 alt126=36;
 19092   
                 }
 19093  4 
                 break;
 19094   
             case SHA1:
 19095  2 
                 {
 19096  2 
                 alt126=37;
 19097   
                 }
 19098  8 
                 break;
 19099   
             case SHA224:
 19100  6 
                 {
 19101  0 
                 alt126=38;
 19102   
                 }
 19103  3 
                 break;
 19104   
             case SHA256:
 19105  3 
                 {
 19106  2 
                 alt126=39;
 19107   
                 }
 19108  5 
                 break;
 19109   
             case SHA384:
 19110  3 
                 {
 19111  2 
                 alt126=40;
 19112   
                 }
 19113  5 
                 break;
 19114   
             case SHA512:
 19115  3 
                 {
 19116  2 
                 alt126=41;
 19117   
                 }
 19118  17 
                 break;
 19119   
             case COALESCE:
 19120  15 
                 {
 19121  6 
                 alt126=42;
 19122   
                 }
 19123  10 
                 break;
 19124   
             case IF:
 19125  4 
                 {
 19126  3 
                 alt126=43;
 19127   
                 }
 19128  4 
                 break;
 19129   
             case STRLANG:
 19130  1 
                 {
 19131  3 
                 alt126=44;
 19132   
                 }
 19133  7 
                 break;
 19134   
             case STRDT:
 19135  4 
                 {
 19136  3 
                 alt126=45;
 19137   
                 }
 19138  7 
                 break;
 19139   
             case SAMETERM:
 19140  4 
                 {
 19141  15 
                 alt126=46;
 19142   
                 }
 19143  17 
                 break;
 19144   
             case ISIRI:
 19145  2 
                 {
 19146  4 
                 alt126=47;
 19147   
                 }
 19148  25 
                 break;
 19149   
             case ISURI:
 19150  21 
                 {
 19151  1 
                 alt126=48;
 19152   
                 }
 19153  11 
                 break;
 19154   
             case ISBLANK:
 19155  10 
                 {
 19156  4 
                 alt126=49;
 19157   
                 }
 19158  27 
                 break;
 19159   
             case ISLITERAL:
 19160  23 
                 {
 19161  4 
                 alt126=50;
 19162   
                 }
 19163  4 
                 break;
 19164   
             case ISNUMERIC:
 19165   
                 {
 19166  2 
                 alt126=51;
 19167   
                 }
 19168  2 
                 break;
 19169  266 
             case REGEX:
 19170   
                 {
 19171  21 
                 alt126=52;
 19172   
                 }
 19173  39 
                 break;
 19174  18 
             case EXISTS:
 19175   
                 {
 19176  10 
                 alt126=53;
 19177  18 
                 }
 19178  28 
                 break;
 19179   
             case NOT:
 19180   
                 {
 19181  41 
                 alt126=54;
 19182  18 
                 }
 19183  23 
                 break;
 19184  18 
             default:
 19185  0 
                 NoViableAltException nvae =
 19186  18 
                     new NoViableAltException("", 126, 0, input);
 19187   
 
 19188  18 
                 throw nvae;
 19189  18 
 
 19190   
             }
 19191   
 
 19192  266 
             switch (alt126) {
 19193   
                 case 1 :
 19194   
                     // com\\googlecode\\sparkleg\\Sparql.g:540:7: STR OPEN_BRACE expression CLOSE_BRACE
 19195   
                     {
 19196  18 
                     STR386=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5008);
 19197  18 
                     stream_STR.add(STR386);
 19198   
 
 19199  18 
 
 19200  36 
                     OPEN_BRACE387=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5010);
 19201  18 
                     stream_OPEN_BRACE.add(OPEN_BRACE387);
 19202  18 
 
 19203   
 
 19204  18 
                     pushFollow(FOLLOW_expression_in_builtInCall5012);
 19205  18 
                     expression388=expression();
 19206   
 
 19207  36 
                     state._fsp--;
 19208  18 
 
 19209  18 
                     stream_expression.add(expression388.getTree());
 19210   
 
 19211  18 
                     CLOSE_BRACE389=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5014);
 19212  36 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE389);
 19213   
 
 19214  18 
 
 19215   
                     // AST REWRITE
 19216   
                     // elements: STR, expression
 19217   
                     // token labels:
 19218   
                     // rule labels: retval
 19219   
                     // token list labels:
 19220  18 
                     // rule list labels:
 19221   
                     // wildcard labels:
 19222  18 
                     retval.tree = root_0;
 19223  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19224   
 
 19225  18 
                     root_0 = (Object)adaptor.nil();
 19226   
                     // 540:45: -> ^( STR expression )
 19227  20 
                     {
 19228  20 
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: ^( STR expression )
 19229   
                         {
 19230  18 
                         Object root_1 = (Object)adaptor.nil();
 19231  38 
                         root_1 = (Object)adaptor.becomeRoot(
 19232  20 
                         stream_STR.nextNode()
 19233   
                         , root_1);
 19234   
 
 19235  38 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19236  20 
 
 19237  18 
                         adaptor.addChild(root_0, root_1);
 19238  20 
                         }
 19239   
 
 19240  20 
                     }
 19241   
 
 19242  20 
 
 19243  38 
                     retval.tree = root_0;
 19244   
 
 19245   
                     }
 19246  18 
                     break;
 19247   
                 case 2 :
 19248   
                     // com\\googlecode\\sparkleg\\Sparql.g:541:7: LANG OPEN_BRACE expression CLOSE_BRACE
 19249   
                     {
 19250  20 
                     LANG390=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5030);
 19251  20 
                     stream_LANG.add(LANG390);
 19252   
 
 19253  20 
 
 19254  40 
                     OPEN_BRACE391=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5032);
 19255  20 
                     stream_OPEN_BRACE.add(OPEN_BRACE391);
 19256  20 
 
 19257   
 
 19258  20 
                     pushFollow(FOLLOW_expression_in_builtInCall5034);
 19259  20 
                     expression392=expression();
 19260   
 
 19261  40 
                     state._fsp--;
 19262  20 
 
 19263  20 
                     stream_expression.add(expression392.getTree());
 19264   
 
 19265  20 
                     CLOSE_BRACE393=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5036);
 19266  40 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE393);
 19267   
 
 19268  20 
 
 19269   
                     // AST REWRITE
 19270   
                     // elements: expression, LANG
 19271   
                     // token labels:
 19272   
                     // rule labels: retval
 19273   
                     // token list labels:
 19274  20 
                     // rule list labels:
 19275   
                     // wildcard labels:
 19276  20 
                     retval.tree = root_0;
 19277  40 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19278   
 
 19279  20 
                     root_0 = (Object)adaptor.nil();
 19280   
                     // 541:46: -> ^( LANG expression )
 19281  15 
                     {
 19282  15 
                         // com\\googlecode\\sparkleg\\Sparql.g:541:49: ^( LANG expression )
 19283   
                         {
 19284  20 
                         Object root_1 = (Object)adaptor.nil();
 19285  35 
                         root_1 = (Object)adaptor.becomeRoot(
 19286  15 
                         stream_LANG.nextNode()
 19287   
                         , root_1);
 19288   
 
 19289  35 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19290  15 
 
 19291  20 
                         adaptor.addChild(root_0, root_1);
 19292  15 
                         }
 19293   
 
 19294  15 
                     }
 19295   
 
 19296  15 
 
 19297  35 
                     retval.tree = root_0;
 19298   
 
 19299   
                     }
 19300  35 
                     break;
 19301  15 
                 case 3 :
 19302   
                     // com\\googlecode\\sparkleg\\Sparql.g:542:7: LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE
 19303  15 
                     {
 19304  15 
                     LANGMATCHES394=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5052);
 19305  30 
                     stream_LANGMATCHES.add(LANGMATCHES394);
 19306   
 
 19307  15 
 
 19308  30 
                     OPEN_BRACE395=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5054);
 19309  15 
                     stream_OPEN_BRACE.add(OPEN_BRACE395);
 19310   
 
 19311   
 
 19312  15 
                     pushFollow(FOLLOW_expression_in_builtInCall5056);
 19313  15 
                     expression396=expression();
 19314   
 
 19315  15 
                     state._fsp--;
 19316   
 
 19317  15 
                     stream_expression.add(expression396.getTree());
 19318  15 
 
 19319  30 
                     COMMA397=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5058);
 19320  15 
                     stream_COMMA.add(COMMA397);
 19321  15 
 
 19322   
 
 19323  15 
                     pushFollow(FOLLOW_expression_in_builtInCall5060);
 19324  15 
                     expression398=expression();
 19325   
 
 19326  30 
                     state._fsp--;
 19327  15 
 
 19328  15 
                     stream_expression.add(expression398.getTree());
 19329   
 
 19330  15 
                     CLOSE_BRACE399=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5062);
 19331  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE399);
 19332   
 
 19333   
 
 19334  45 
                     // AST REWRITE
 19335  30 
                     // elements: LANGMATCHES, expression
 19336   
                     // token labels:
 19337   
                     // rule labels: retval
 19338  15 
                     // token list labels:
 19339   
                     // rule list labels:
 19340  15 
                     // wildcard labels:
 19341  15 
                     retval.tree = root_0;
 19342  15 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19343   
 
 19344  15 
                     root_0 = (Object)adaptor.nil();
 19345   
                     // 542:70: -> ^( LANGMATCHES ( expression )+ )
 19346  15 
                     {
 19347   
                         // com\\googlecode\\sparkleg\\Sparql.g:542:73: ^( LANGMATCHES ( expression )+ )
 19348   
                         {
 19349  30 
                         Object root_1 = (Object)adaptor.nil();
 19350  15 
                         root_1 = (Object)adaptor.becomeRoot(
 19351   
                         stream_LANGMATCHES.nextNode()
 19352   
                         , root_1);
 19353  50 
 
 19354  65 
                         if ( !(stream_expression.hasNext()) ) {
 19355  0 
                             throw new RewriteEarlyExitException();
 19356   
                         }
 19357  95 
                         while ( stream_expression.hasNext() ) {
 19358  80 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19359   
 
 19360   
                         }
 19361  65 
                         stream_expression.reset();
 19362  50 
 
 19363  15 
                         adaptor.addChild(root_0, root_1);
 19364  50 
                         }
 19365   
 
 19366  50 
                     }
 19367   
 
 19368  50 
 
 19369  65 
                     retval.tree = root_0;
 19370   
 
 19371   
                     }
 19372  15 
                     break;
 19373   
                 case 4 :
 19374   
                     // com\\googlecode\\sparkleg\\Sparql.g:543:7: DATATYPE OPEN_BRACE expression CLOSE_BRACE
 19375   
                     {
 19376  50 
                     DATATYPE400=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5079);
 19377  50 
                     stream_DATATYPE.add(DATATYPE400);
 19378   
 
 19379  50 
 
 19380  100 
                     OPEN_BRACE401=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5081);
 19381  50 
                     stream_OPEN_BRACE.add(OPEN_BRACE401);
 19382  50 
 
 19383   
 
 19384  50 
                     pushFollow(FOLLOW_expression_in_builtInCall5083);
 19385  50 
                     expression402=expression();
 19386   
 
 19387  100 
                     state._fsp--;
 19388  50 
 
 19389  50 
                     stream_expression.add(expression402.getTree());
 19390   
 
 19391  50 
                     CLOSE_BRACE403=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5085);
 19392  100 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE403);
 19393   
 
 19394  50 
 
 19395   
                     // AST REWRITE
 19396   
                     // elements: DATATYPE, expression
 19397   
                     // token labels:
 19398   
                     // rule labels: retval
 19399   
                     // token list labels:
 19400  50 
                     // rule list labels:
 19401   
                     // wildcard labels:
 19402  50 
                     retval.tree = root_0;
 19403  100 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19404   
 
 19405  50 
                     root_0 = (Object)adaptor.nil();
 19406   
                     // 543:50: -> ^( DATATYPE expression )
 19407  15 
                     {
 19408  15 
                         // com\\googlecode\\sparkleg\\Sparql.g:543:53: ^( DATATYPE expression )
 19409   
                         {
 19410  50 
                         Object root_1 = (Object)adaptor.nil();
 19411  65 
                         root_1 = (Object)adaptor.becomeRoot(
 19412  15 
                         stream_DATATYPE.nextNode()
 19413   
                         , root_1);
 19414   
 
 19415  65 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19416  15 
 
 19417  50 
                         adaptor.addChild(root_0, root_1);
 19418  15 
                         }
 19419   
 
 19420  15 
                     }
 19421   
 
 19422  15 
 
 19423  65 
                     retval.tree = root_0;
 19424   
 
 19425   
                     }
 19426  50 
                     break;
 19427   
                 case 5 :
 19428   
                     // com\\googlecode\\sparkleg\\Sparql.g:544:7: BOUND OPEN_BRACE var CLOSE_BRACE
 19429   
                     {
 19430  15 
                     BOUND404=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5101);
 19431  15 
                     stream_BOUND.add(BOUND404);
 19432   
 
 19433  15 
 
 19434  30 
                     OPEN_BRACE405=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5103);
 19435  15 
                     stream_OPEN_BRACE.add(OPEN_BRACE405);
 19436  15 
 
 19437   
 
 19438  15 
                     pushFollow(FOLLOW_var_in_builtInCall5105);
 19439  15 
                     var406=var();
 19440   
 
 19441  30 
                     state._fsp--;
 19442  15 
 
 19443  15 
                     stream_var.add(var406.getTree());
 19444   
 
 19445  15 
                     CLOSE_BRACE407=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5107);
 19446  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE407);
 19447   
 
 19448  15 
 
 19449   
                     // AST REWRITE
 19450   
                     // elements: var, BOUND
 19451   
                     // token labels:
 19452   
                     // rule labels: retval
 19453   
                     // token list labels:
 19454  15 
                     // rule list labels:
 19455   
                     // wildcard labels:
 19456  15 
                     retval.tree = root_0;
 19457  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19458   
 
 19459  15 
                     root_0 = (Object)adaptor.nil();
 19460   
                     // 544:40: -> ^( BOUND var )
 19461  1 
                     {
 19462  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:544:43: ^( BOUND var )
 19463   
                         {
 19464  15 
                         Object root_1 = (Object)adaptor.nil();
 19465  16 
                         root_1 = (Object)adaptor.becomeRoot(
 19466  1 
                         stream_BOUND.nextNode()
 19467   
                         , root_1);
 19468   
 
 19469  16 
                         adaptor.addChild(root_1, stream_var.nextTree());
 19470  1 
 
 19471  15 
                         adaptor.addChild(root_0, root_1);
 19472  1 
                         }
 19473   
 
 19474  1 
                     }
 19475   
 
 19476  1 
 
 19477  16 
                     retval.tree = root_0;
 19478   
 
 19479   
                     }
 19480  15 
                     break;
 19481   
                 case 6 :
 19482   
                     // com\\googlecode\\sparkleg\\Sparql.g:545:7: IRI OPEN_BRACE expression CLOSE_BRACE
 19483   
                     {
 19484  1 
                     IRI408=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5123);
 19485  1 
                     stream_IRI.add(IRI408);
 19486   
 
 19487  1 
 
 19488  2 
                     OPEN_BRACE409=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5125);
 19489  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE409);
 19490  1 
 
 19491   
 
 19492  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5127);
 19493  1 
                     expression410=expression();
 19494   
 
 19495  2 
                     state._fsp--;
 19496  1 
 
 19497  1 
                     stream_expression.add(expression410.getTree());
 19498   
 
 19499  1 
                     CLOSE_BRACE411=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5129);
 19500  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE411);
 19501   
 
 19502  1 
 
 19503   
                     // AST REWRITE
 19504   
                     // elements: expression, IRI
 19505   
                     // token labels:
 19506   
                     // rule labels: retval
 19507   
                     // token list labels:
 19508  1 
                     // rule list labels:
 19509   
                     // wildcard labels:
 19510  1 
                     retval.tree = root_0;
 19511  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19512   
 
 19513  1 
                     root_0 = (Object)adaptor.nil();
 19514   
                     // 545:45: -> ^( IRI expression )
 19515  1 
                     {
 19516  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:545:48: ^( IRI expression )
 19517   
                         {
 19518  1 
                         Object root_1 = (Object)adaptor.nil();
 19519  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19520  1 
                         stream_IRI.nextNode()
 19521   
                         , root_1);
 19522   
 
 19523  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19524  1 
 
 19525  1 
                         adaptor.addChild(root_0, root_1);
 19526  1 
                         }
 19527   
 
 19528  1 
                     }
 19529   
 
 19530  1 
 
 19531  2 
                     retval.tree = root_0;
 19532   
 
 19533   
                     }
 19534  1 
                     break;
 19535   
                 case 7 :
 19536   
                     // com\\googlecode\\sparkleg\\Sparql.g:546:7: URI OPEN_BRACE expression CLOSE_BRACE
 19537   
                     {
 19538  1 
                     URI412=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5145);
 19539  1 
                     stream_URI.add(URI412);
 19540   
 
 19541  1 
 
 19542  2 
                     OPEN_BRACE413=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5147);
 19543  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE413);
 19544  1 
 
 19545   
 
 19546  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5149);
 19547  1 
                     expression414=expression();
 19548   
 
 19549  2 
                     state._fsp--;
 19550  1 
 
 19551  1 
                     stream_expression.add(expression414.getTree());
 19552   
 
 19553  1 
                     CLOSE_BRACE415=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5151);
 19554  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE415);
 19555   
 
 19556  1 
 
 19557   
                     // AST REWRITE
 19558   
                     // elements: expression, URI
 19559   
                     // token labels:
 19560   
                     // rule labels: retval
 19561   
                     // token list labels:
 19562  1 
                     // rule list labels:
 19563   
                     // wildcard labels:
 19564  1 
                     retval.tree = root_0;
 19565  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19566   
 
 19567  1 
                     root_0 = (Object)adaptor.nil();
 19568   
                     // 546:45: -> ^( URI expression )
 19569  2 
                     {
 19570  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:546:48: ^( URI expression )
 19571   
                         {
 19572  1 
                         Object root_1 = (Object)adaptor.nil();
 19573  1 
                         root_1 = (Object)adaptor.becomeRoot(
 19574   
                         stream_URI.nextNode()
 19575   
                         , root_1);
 19576  2 
 
 19577  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19578   
 
 19579  1 
                         adaptor.addChild(root_0, root_1);
 19580  2 
                         }
 19581  2 
 
 19582   
                     }
 19583  2 
 
 19584   
 
 19585  3 
                     retval.tree = root_0;
 19586   
 
 19587  2 
                     }
 19588  3 
                     break;
 19589   
                 case 8 :
 19590   
                     // com\\googlecode\\sparkleg\\Sparql.g:547:7: BNODE ( OPEN_BRACE expression CLOSE_BRACE )
 19591   
                     {
 19592  2 
                     BNODE416=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5167);
 19593  2 
                     stream_BNODE.add(BNODE416);
 19594   
 
 19595   
 
 19596   
                     // com\\googlecode\\sparkleg\\Sparql.g:547:13: ( OPEN_BRACE expression CLOSE_BRACE )
 19597   
                     // com\\googlecode\\sparkleg\\Sparql.g:547:14: OPEN_BRACE expression CLOSE_BRACE
 19598   
                     {
 19599  2 
                     OPEN_BRACE417=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5170);
 19600  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE417);
 19601  2 
 
 19602  2 
 
 19603  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5172);
 19604  4 
                     expression418=expression();
 19605   
 
 19606  2 
                     state._fsp--;
 19607   
 
 19608  2 
                     stream_expression.add(expression418.getTree());
 19609  2 
 
 19610  4 
                     CLOSE_BRACE419=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5174);
 19611  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE419);
 19612   
 
 19613   
 
 19614  2 
                     }
 19615   
 
 19616  2 
 
 19617   
                     // AST REWRITE
 19618   
                     // elements: BNODE, expression
 19619   
                     // token labels:
 19620   
                     // rule labels: retval
 19621   
                     // token list labels:
 19622  2 
                     // rule list labels:
 19623   
                     // wildcard labels:
 19624  2 
                     retval.tree = root_0;
 19625  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19626   
 
 19627  2 
                     root_0 = (Object)adaptor.nil();
 19628   
                     // 547:49: -> ^( BNODE expression )
 19629  2 
                     {
 19630  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:547:52: ^( BNODE expression )
 19631   
                         {
 19632  2 
                         Object root_1 = (Object)adaptor.nil();
 19633  4 
                         root_1 = (Object)adaptor.becomeRoot(
 19634  2 
                         stream_BNODE.nextNode()
 19635   
                         , root_1);
 19636  2 
 
 19637  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19638  2 
 
 19639  2 
                         adaptor.addChild(root_0, root_1);
 19640   
                         }
 19641   
 
 19642   
                     }
 19643   
 
 19644   
 
 19645  2 
                     retval.tree = root_0;
 19646   
 
 19647  2 
                     }
 19648  4 
                     break;
 19649   
                 case 9 :
 19650  2 
                     // com\\googlecode\\sparkleg\\Sparql.g:548:7: BNODE nil
 19651   
                     {
 19652  2 
                     BNODE420=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5191);
 19653  4 
                     stream_BNODE.add(BNODE420);
 19654   
 
 19655   
 
 19656  2 
                     pushFollow(FOLLOW_nil_in_builtInCall5193);
 19657  2 
                     nil421=nil();
 19658   
 
 19659  2 
                     state._fsp--;
 19660  2 
 
 19661  2 
                     stream_nil.add(nil421.getTree());
 19662   
 
 19663  2 
                     // AST REWRITE
 19664   
                     // elements: BNODE
 19665   
                     // token labels:
 19666   
                     // rule labels: retval
 19667  1 
                     // token list labels:
 19668  1 
                     // rule list labels:
 19669   
                     // wildcard labels:
 19670  2 
                     retval.tree = root_0;
 19671  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19672  1 
 
 19673  2 
                     root_0 = (Object)adaptor.nil();
 19674  1 
                     // 548:17: -> BNODE
 19675   
                     {
 19676  3 
                         adaptor.addChild(root_0,
 19677   
                         stream_BNODE.nextNode()
 19678   
                         );
 19679   
 
 19680   
                     }
 19681   
 
 19682   
 
 19683  2 
                     retval.tree = root_0;
 19684   
 
 19685  1 
                     }
 19686  3 
                     break;
 19687   
                 case 10 :
 19688  1 
                     // com\\googlecode\\sparkleg\\Sparql.g:549:7: RAND nil
 19689   
                     {
 19690  1 
                     RAND422=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5205);
 19691  2 
                     stream_RAND.add(RAND422);
 19692   
 
 19693   
 
 19694  1 
                     pushFollow(FOLLOW_nil_in_builtInCall5207);
 19695  1 
                     nil423=nil();
 19696   
 
 19697  1 
                     state._fsp--;
 19698  1 
 
 19699  1 
                     stream_nil.add(nil423.getTree());
 19700   
 
 19701  1 
                     // AST REWRITE
 19702   
                     // elements: RAND
 19703   
                     // token labels:
 19704   
                     // rule labels: retval
 19705  1 
                     // token list labels:
 19706  1 
                     // rule list labels:
 19707   
                     // wildcard labels:
 19708  1 
                     retval.tree = root_0;
 19709  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19710  1 
 
 19711  1 
                     root_0 = (Object)adaptor.nil();
 19712   
                     // 549:16: -> RAND
 19713  1 
                     {
 19714  2 
                         adaptor.addChild(root_0,
 19715   
                         stream_RAND.nextNode()
 19716  1 
                         );
 19717   
 
 19718  1 
                     }
 19719   
 
 19720  1 
 
 19721  2 
                     retval.tree = root_0;
 19722   
 
 19723   
                     }
 19724  1 
                     break;
 19725   
                 case 11 :
 19726   
                     // com\\googlecode\\sparkleg\\Sparql.g:550:7: ABS OPEN_BRACE expression CLOSE_BRACE
 19727   
                     {
 19728  1 
                     ABS424=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5219);
 19729  1 
                     stream_ABS.add(ABS424);
 19730   
 
 19731  1 
 
 19732  2 
                     OPEN_BRACE425=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5221);
 19733  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE425);
 19734  1 
 
 19735   
 
 19736  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5223);
 19737  1 
                     expression426=expression();
 19738   
 
 19739  2 
                     state._fsp--;
 19740  1 
 
 19741  1 
                     stream_expression.add(expression426.getTree());
 19742   
 
 19743  1 
                     CLOSE_BRACE427=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5225);
 19744  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE427);
 19745   
 
 19746  1 
 
 19747   
                     // AST REWRITE
 19748   
                     // elements: ABS, expression
 19749   
                     // token labels:
 19750   
                     // rule labels: retval
 19751   
                     // token list labels:
 19752  1 
                     // rule list labels:
 19753   
                     // wildcard labels:
 19754  1 
                     retval.tree = root_0;
 19755  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19756   
 
 19757  1 
                     root_0 = (Object)adaptor.nil();
 19758   
                     // 550:45: -> ^( ABS expression )
 19759  1 
                     {
 19760  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:550:48: ^( ABS expression )
 19761   
                         {
 19762  1 
                         Object root_1 = (Object)adaptor.nil();
 19763  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19764  1 
                         stream_ABS.nextNode()
 19765   
                         , root_1);
 19766   
 
 19767  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19768  1 
 
 19769  1 
                         adaptor.addChild(root_0, root_1);
 19770  1 
                         }
 19771   
 
 19772  1 
                     }
 19773   
 
 19774  1 
 
 19775  2 
                     retval.tree = root_0;
 19776   
 
 19777   
                     }
 19778  1 
                     break;
 19779   
                 case 12 :
 19780   
                     // com\\googlecode\\sparkleg\\Sparql.g:551:7: CEIL OPEN_BRACE expression CLOSE_BRACE
 19781   
                     {
 19782  1 
                     CEIL428=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5241);
 19783  1 
                     stream_CEIL.add(CEIL428);
 19784   
 
 19785  1 
 
 19786  2 
                     OPEN_BRACE429=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5243);
 19787  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE429);
 19788  1 
 
 19789   
 
 19790  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5245);
 19791  1 
                     expression430=expression();
 19792   
 
 19793  2 
                     state._fsp--;
 19794  1 
 
 19795  1 
                     stream_expression.add(expression430.getTree());
 19796   
 
 19797  1 
                     CLOSE_BRACE431=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5247);
 19798  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE431);
 19799   
 
 19800  1 
 
 19801   
                     // AST REWRITE
 19802   
                     // elements: expression, CEIL
 19803   
                     // token labels:
 19804   
                     // rule labels: retval
 19805   
                     // token list labels:
 19806  1 
                     // rule list labels:
 19807   
                     // wildcard labels:
 19808  1 
                     retval.tree = root_0;
 19809  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19810   
 
 19811  1 
                     root_0 = (Object)adaptor.nil();
 19812   
                     // 551:46: -> ^( CEIL expression )
 19813  1 
                     {
 19814  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:551:49: ^( CEIL expression )
 19815   
                         {
 19816  1 
                         Object root_1 = (Object)adaptor.nil();
 19817  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19818  1 
                         stream_CEIL.nextNode()
 19819   
                         , root_1);
 19820   
 
 19821  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19822  1 
 
 19823  1 
                         adaptor.addChild(root_0, root_1);
 19824  1 
                         }
 19825   
 
 19826  1 
                     }
 19827   
 
 19828  1 
 
 19829  2 
                     retval.tree = root_0;
 19830   
 
 19831   
                     }
 19832  1 
                     break;
 19833   
                 case 13 :
 19834   
                     // com\\googlecode\\sparkleg\\Sparql.g:552:7: FLOOR OPEN_BRACE expression CLOSE_BRACE
 19835   
                     {
 19836  1 
                     FLOOR432=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5263);
 19837  1 
                     stream_FLOOR.add(FLOOR432);
 19838   
 
 19839  1 
 
 19840  2 
                     OPEN_BRACE433=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5265);
 19841  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE433);
 19842  1 
 
 19843   
 
 19844  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5267);
 19845  1 
                     expression434=expression();
 19846   
 
 19847  2 
                     state._fsp--;
 19848  1 
 
 19849  1 
                     stream_expression.add(expression434.getTree());
 19850   
 
 19851  1 
                     CLOSE_BRACE435=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5269);
 19852  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE435);
 19853   
 
 19854  1 
 
 19855   
                     // AST REWRITE
 19856   
                     // elements: FLOOR, expression
 19857   
                     // token labels:
 19858   
                     // rule labels: retval
 19859   
                     // token list labels:
 19860  1 
                     // rule list labels:
 19861   
                     // wildcard labels:
 19862  1 
                     retval.tree = root_0;
 19863  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19864   
 
 19865  1 
                     root_0 = (Object)adaptor.nil();
 19866   
                     // 552:47: -> ^( FLOOR expression )
 19867  1 
                     {
 19868  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:552:50: ^( FLOOR expression )
 19869   
                         {
 19870  1 
                         Object root_1 = (Object)adaptor.nil();
 19871  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19872  1 
                         stream_FLOOR.nextNode()
 19873   
                         , root_1);
 19874   
 
 19875  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19876  1 
 
 19877  1 
                         adaptor.addChild(root_0, root_1);
 19878  1 
                         }
 19879   
 
 19880  1 
                     }
 19881   
 
 19882  1 
 
 19883  2 
                     retval.tree = root_0;
 19884   
 
 19885   
                     }
 19886  1 
                     break;
 19887   
                 case 14 :
 19888   
                     // com\\googlecode\\sparkleg\\Sparql.g:553:7: ROUND OPEN_BRACE expression CLOSE_BRACE
 19889   
                     {
 19890  1 
                     ROUND436=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5285);
 19891  1 
                     stream_ROUND.add(ROUND436);
 19892   
 
 19893  1 
 
 19894  2 
                     OPEN_BRACE437=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5287);
 19895  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE437);
 19896  1 
 
 19897   
 
 19898  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5289);
 19899  1 
                     expression438=expression();
 19900   
 
 19901  2 
                     state._fsp--;
 19902  1 
 
 19903  1 
                     stream_expression.add(expression438.getTree());
 19904   
 
 19905  1 
                     CLOSE_BRACE439=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5291);
 19906  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE439);
 19907   
 
 19908  1 
 
 19909   
                     // AST REWRITE
 19910   
                     // elements: expression, ROUND
 19911   
                     // token labels:
 19912   
                     // rule labels: retval
 19913   
                     // token list labels:
 19914  1 
                     // rule list labels:
 19915   
                     // wildcard labels:
 19916  1 
                     retval.tree = root_0;
 19917  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19918   
 
 19919  1 
                     root_0 = (Object)adaptor.nil();
 19920   
                     // 553:47: -> ^( ROUND expression )
 19921  5 
                     {
 19922  5 
                         // com\\googlecode\\sparkleg\\Sparql.g:553:50: ^( ROUND expression )
 19923   
                         {
 19924  1 
                         Object root_1 = (Object)adaptor.nil();
 19925  6 
                         root_1 = (Object)adaptor.becomeRoot(
 19926  5 
                         stream_ROUND.nextNode()
 19927   
                         , root_1);
 19928  5 
 
 19929  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19930  5 
 
 19931  1 
                         adaptor.addChild(root_0, root_1);
 19932   
                         }
 19933   
 
 19934   
                     }
 19935   
 
 19936   
 
 19937  1 
                     retval.tree = root_0;
 19938   
 
 19939  5 
                     }
 19940  6 
                     break;
 19941   
                 case 15 :
 19942  5 
                     // com\\googlecode\\sparkleg\\Sparql.g:554:7: CONCAT expressionList
 19943   
                     {
 19944  5 
                     CONCAT440=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5307);
 19945  5 
                     stream_CONCAT.add(CONCAT440);
 19946   
 
 19947  5 
 
 19948  10 
                     pushFollow(FOLLOW_expressionList_in_builtInCall5309);
 19949  5 
                     expressionList441=expressionList();
 19950   
 
 19951  5 
                     state._fsp--;
 19952  5 
 
 19953  5 
                     stream_expressionList.add(expressionList441.getTree());
 19954  5 
 
 19955   
                     // AST REWRITE
 19956   
                     // elements: expressionList, CONCAT
 19957   
                     // token labels:
 19958   
                     // rule labels: retval
 19959   
                     // token list labels:
 19960  5 
                     // rule list labels:
 19961   
                     // wildcard labels:
 19962  5 
                     retval.tree = root_0;
 19963  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19964   
 
 19965  5 
                     root_0 = (Object)adaptor.nil();
 19966   
                     // 554:29: -> ^( CONCAT expressionList )
 19967  2 
                     {
 19968  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:554:32: ^( CONCAT expressionList )
 19969   
                         {
 19970  7 
                         Object root_1 = (Object)adaptor.nil();
 19971  5 
                         root_1 = (Object)adaptor.becomeRoot(
 19972  2 
                         stream_CONCAT.nextNode()
 19973   
                         , root_1);
 19974   
 
 19975  5 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 19976   
 
 19977  5 
                         adaptor.addChild(root_0, root_1);
 19978   
                         }
 19979   
 
 19980   
                     }
 19981  2 
 
 19982  2 
 
 19983  5 
                     retval.tree = root_0;
 19984  2 
 
 19985   
                     }
 19986  5 
                     break;
 19987  2 
                 case 16 :
 19988   
                     // com\\googlecode\\sparkleg\\Sparql.g:555:7: subStringExpression
 19989   
                     {
 19990  2 
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5325);
 19991  2 
                     subStringExpression442=subStringExpression();
 19992  2 
 
 19993  2 
                     state._fsp--;
 19994   
 
 19995  4 
                     stream_subStringExpression.add(subStringExpression442.getTree());
 19996   
 
 19997   
                     // AST REWRITE
 19998   
                     // elements: subStringExpression
 19999  1 
                     // token labels:
 20000  1 
                     // rule labels: retval
 20001   
                     // token list labels:
 20002   
                     // rule list labels:
 20003  1 
                     // wildcard labels:
 20004  3 
                     retval.tree = root_0;
 20005  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20006   
 
 20007  3 
                     root_0 = (Object)adaptor.nil();
 20008  1 
                     // 555:27: -> subStringExpression
 20009   
                     {
 20010  3 
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20011   
 
 20012  1 
                     }
 20013   
 
 20014  1 
 
 20015  3 
                     retval.tree = root_0;
 20016   
 
 20017   
                     }
 20018  2 
                     break;
 20019   
                 case 17 :
 20020   
                     // com\\googlecode\\sparkleg\\Sparql.g:556:7: STRLEN OPEN_BRACE expression CLOSE_BRACE
 20021   
                     {
 20022  1 
                     STRLEN443=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5337);
 20023  1 
                     stream_STRLEN.add(STRLEN443);
 20024   
 
 20025  1 
 
 20026  2 
                     OPEN_BRACE444=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5339);
 20027  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE444);
 20028  1 
 
 20029   
 
 20030  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5341);
 20031  1 
                     expression445=expression();
 20032   
 
 20033  2 
                     state._fsp--;
 20034  1 
 
 20035  1 
                     stream_expression.add(expression445.getTree());
 20036   
 
 20037  1 
                     CLOSE_BRACE446=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5343);
 20038  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE446);
 20039   
 
 20040  1 
 
 20041   
                     // AST REWRITE
 20042   
                     // elements: STRLEN, expression
 20043   
                     // token labels:
 20044   
                     // rule labels: retval
 20045   
                     // token list labels:
 20046  1 
                     // rule list labels:
 20047   
                     // wildcard labels:
 20048  1 
                     retval.tree = root_0;
 20049  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20050   
 
 20051  1 
                     root_0 = (Object)adaptor.nil();
 20052   
                     // 556:48: -> ^( STRLEN expression )
 20053  1 
                     {
 20054  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:556:51: ^( STRLEN expression )
 20055   
                         {
 20056  1 
                         Object root_1 = (Object)adaptor.nil();
 20057  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20058  1 
                         stream_STRLEN.nextNode()
 20059   
                         , root_1);
 20060   
 
 20061  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20062  1 
 
 20063  1 
                         adaptor.addChild(root_0, root_1);
 20064  1 
                         }
 20065   
 
 20066  1 
                     }
 20067   
 
 20068  1 
 
 20069  2 
                     retval.tree = root_0;
 20070   
 
 20071   
                     }
 20072  1 
                     break;
 20073   
                 case 18 :
 20074   
                     // com\\googlecode\\sparkleg\\Sparql.g:557:7: UCASE OPEN_BRACE expression CLOSE_BRACE
 20075   
                     {
 20076  1 
                     UCASE447=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5359);
 20077  1 
                     stream_UCASE.add(UCASE447);
 20078   
 
 20079  1 
 
 20080  2 
                     OPEN_BRACE448=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5361);
 20081  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE448);
 20082  1 
 
 20083   
 
 20084  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5363);
 20085  1 
                     expression449=expression();
 20086   
 
 20087  2 
                     state._fsp--;
 20088  1 
 
 20089  1 
                     stream_expression.add(expression449.getTree());
 20090   
 
 20091  1 
                     CLOSE_BRACE450=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5365);
 20092  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE450);
 20093   
 
 20094  1 
 
 20095   
                     // AST REWRITE
 20096   
                     // elements: expression, UCASE
 20097   
                     // token labels:
 20098   
                     // rule labels: retval
 20099   
                     // token list labels:
 20100  1 
                     // rule list labels:
 20101   
                     // wildcard labels:
 20102  1 
                     retval.tree = root_0;
 20103  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20104   
 
 20105  1 
                     root_0 = (Object)adaptor.nil();
 20106   
                     // 557:47: -> ^( UCASE expression )
 20107  1 
                     {
 20108  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:557:50: ^( UCASE expression )
 20109   
                         {
 20110  1 
                         Object root_1 = (Object)adaptor.nil();
 20111  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20112  1 
                         stream_UCASE.nextNode()
 20113   
                         , root_1);
 20114   
 
 20115  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20116  1 
 
 20117  1 
                         adaptor.addChild(root_0, root_1);
 20118  1 
                         }
 20119   
 
 20120  1 
                     }
 20121   
 
 20122  1 
 
 20123  2 
                     retval.tree = root_0;
 20124   
 
 20125   
                     }
 20126  1 
                     break;
 20127   
                 case 19 :
 20128   
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: LCASE OPEN_BRACE expression CLOSE_BRACE
 20129   
                     {
 20130  1 
                     LCASE451=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5381);
 20131  1 
                     stream_LCASE.add(LCASE451);
 20132   
 
 20133  1 
 
 20134  2 
                     OPEN_BRACE452=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5383);
 20135  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE452);
 20136  1 
 
 20137   
 
 20138  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5385);
 20139  1 
                     expression453=expression();
 20140   
 
 20141  2 
                     state._fsp--;
 20142  1 
 
 20143  1 
                     stream_expression.add(expression453.getTree());
 20144   
 
 20145  1 
                     CLOSE_BRACE454=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5387);
 20146  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE454);
 20147   
 
 20148  1 
 
 20149   
                     // AST REWRITE
 20150   
                     // elements: expression, LCASE
 20151   
                     // token labels:
 20152   
                     // rule labels: retval
 20153   
                     // token list labels:
 20154  1 
                     // rule list labels:
 20155   
                     // wildcard labels:
 20156  1 
                     retval.tree = root_0;
 20157  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20158   
 
 20159  1 
                     root_0 = (Object)adaptor.nil();
 20160   
                     // 558:47: -> ^( LCASE expression )
 20161  1 
                     {
 20162  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:558:50: ^( LCASE expression )
 20163   
                         {
 20164  1 
                         Object root_1 = (Object)adaptor.nil();
 20165  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20166  1 
                         stream_LCASE.nextNode()
 20167   
                         , root_1);
 20168   
 
 20169  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20170  1 
 
 20171  1 
                         adaptor.addChild(root_0, root_1);
 20172  1 
                         }
 20173   
 
 20174  1 
                     }
 20175   
 
 20176  1 
 
 20177  2 
                     retval.tree = root_0;
 20178   
 
 20179   
                     }
 20180  1 
                     break;
 20181   
                 case 20 :
 20182   
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE
 20183   
                     {
 20184  1 
                     ENCODE_FOR_URI455=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5403);
 20185  1 
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI455);
 20186   
 
 20187  1 
 
 20188  2 
                     OPEN_BRACE456=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5405);
 20189  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE456);
 20190  1 
 
 20191   
 
 20192  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5407);
 20193  1 
                     expression457=expression();
 20194   
 
 20195  2 
                     state._fsp--;
 20196  1 
 
 20197  1 
                     stream_expression.add(expression457.getTree());
 20198   
 
 20199  1 
                     CLOSE_BRACE458=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5409);
 20200  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE458);
 20201   
 
 20202  1 
 
 20203   
                     // AST REWRITE
 20204   
                     // elements: expression, ENCODE_FOR_URI
 20205   
                     // token labels:
 20206   
                     // rule labels: retval
 20207   
                     // token list labels:
 20208  1 
                     // rule list labels:
 20209   
                     // wildcard labels:
 20210  1 
                     retval.tree = root_0;
 20211  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20212   
 
 20213  1 
                     root_0 = (Object)adaptor.nil();
 20214   
                     // 559:56: -> ^( ENCODE_FOR_URI expression )
 20215  1 
                     {
 20216  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:559:59: ^( ENCODE_FOR_URI expression )
 20217   
                         {
 20218  1 
                         Object root_1 = (Object)adaptor.nil();
 20219  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20220  1 
                         stream_ENCODE_FOR_URI.nextNode()
 20221   
                         , root_1);
 20222   
 
 20223  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20224  1 
 
 20225  1 
                         adaptor.addChild(root_0, root_1);
 20226  1 
                         }
 20227   
 
 20228  1 
                     }
 20229   
 
 20230  1 
 
 20231  2 
                     retval.tree = root_0;
 20232   
 
 20233   
                     }
 20234  2 
                     break;
 20235  1 
                 case 21 :
 20236   
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20237  1 
                     {
 20238  1 
                     CONTAINS459=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5425);
 20239  2 
                     stream_CONTAINS.add(CONTAINS459);
 20240   
 
 20241  1 
 
 20242  2 
                     OPEN_BRACE460=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5427);
 20243  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE460);
 20244   
 
 20245   
 
 20246  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5429);
 20247  1 
                     expression461=expression();
 20248   
 
 20249  1 
                     state._fsp--;
 20250   
 
 20251  1 
                     stream_expression.add(expression461.getTree());
 20252  1 
 
 20253  2 
                     COMMA462=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5431);
 20254  1 
                     stream_COMMA.add(COMMA462);
 20255  1 
 
 20256   
 
 20257  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5433);
 20258  1 
                     expression463=expression();
 20259   
 
 20260  2 
                     state._fsp--;
 20261  1 
 
 20262  1 
                     stream_expression.add(expression463.getTree());
 20263   
 
 20264  1 
                     CLOSE_BRACE464=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5435);
 20265  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE464);
 20266   
 
 20267  1 
 
 20268   
                     // AST REWRITE
 20269  1 
                     // elements: expression, expression, CONTAINS
 20270   
                     // token labels:
 20271   
                     // rule labels: retval
 20272   
                     // token list labels:
 20273   
                     // rule list labels:
 20274   
                     // wildcard labels:
 20275  2 
                     retval.tree = root_0;
 20276  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20277   
 
 20278  2 
                     root_0 = (Object)adaptor.nil();
 20279   
                     // 560:67: -> ^( CONTAINS expression expression )
 20280   
                     {
 20281   
                         // com\\googlecode\\sparkleg\\Sparql.g:560:70: ^( CONTAINS expression expression )
 20282  1 
                         {
 20283  2 
                         Object root_1 = (Object)adaptor.nil();
 20284  1 
                         root_1 = (Object)adaptor.becomeRoot(
 20285   
                         stream_CONTAINS.nextNode()
 20286  1 
                         , root_1);
 20287  1 
 
 20288  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20289   
 
 20290  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20291  1 
 
 20292  1 
                         adaptor.addChild(root_0, root_1);
 20293  1 
                         }
 20294   
 
 20295  1 
                     }
 20296   
 
 20297  1 
 
 20298  2 
                     retval.tree = root_0;
 20299   
 
 20300   
                     }
 20301  2 
                     break;
 20302  1 
                 case 22 :
 20303   
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20304  1 
                     {
 20305  1 
                     STRSTARTS465=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5453);
 20306  2 
                     stream_STRSTARTS.add(STRSTARTS465);
 20307   
 
 20308  1 
 
 20309  2 
                     OPEN_BRACE466=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5455);
 20310  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE466);
 20311   
 
 20312   
 
 20313  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5457);
 20314  1 
                     expression467=expression();
 20315   
 
 20316  1 
                     state._fsp--;
 20317   
 
 20318  1 
                     stream_expression.add(expression467.getTree());
 20319  1 
 
 20320  2 
                     COMMA468=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5459);
 20321  1 
                     stream_COMMA.add(COMMA468);
 20322  1 
 
 20323   
 
 20324  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5461);
 20325  1 
                     expression469=expression();
 20326   
 
 20327  2 
                     state._fsp--;
 20328  1 
 
 20329  1 
                     stream_expression.add(expression469.getTree());
 20330   
 
 20331  1 
                     CLOSE_BRACE470=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5463);
 20332  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE470);
 20333   
 
 20334  1 
 
 20335   
                     // AST REWRITE
 20336  1 
                     // elements: STRSTARTS, expression, expression
 20337   
                     // token labels:
 20338   
                     // rule labels: retval
 20339   
                     // token list labels:
 20340   
                     // rule list labels:
 20341   
                     // wildcard labels:
 20342  2 
                     retval.tree = root_0;
 20343  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20344   
 
 20345  2 
                     root_0 = (Object)adaptor.nil();
 20346   
                     // 561:68: -> ^( STRSTARTS expression expression )
 20347   
                     {
 20348   
                         // com\\googlecode\\sparkleg\\Sparql.g:561:71: ^( STRSTARTS expression expression )
 20349  1 
                         {
 20350  2 
                         Object root_1 = (Object)adaptor.nil();
 20351  1 
                         root_1 = (Object)adaptor.becomeRoot(
 20352   
                         stream_STRSTARTS.nextNode()
 20353  1 
                         , root_1);
 20354  1 
 
 20355  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20356   
 
 20357  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20358  1 
 
 20359  1 
                         adaptor.addChild(root_0, root_1);
 20360  1 
                         }
 20361   
 
 20362  1 
                     }
 20363   
 
 20364  1 
 
 20365  2 
                     retval.tree = root_0;
 20366   
 
 20367   
                     }
 20368  2 
                     break;
 20369  1 
                 case 23 :
 20370   
                     // com\\googlecode\\sparkleg\\Sparql.g:562:7: STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20371  1 
                     {
 20372  1 
                     STRENDS471=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5481);
 20373  2 
                     stream_STRENDS.add(STRENDS471);
 20374   
 
 20375  1 
 
 20376  2 
                     OPEN_BRACE472=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5483);
 20377  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE472);
 20378   
 
 20379   
 
 20380  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5485);
 20381  1 
                     expression473=expression();
 20382   
 
 20383  1 
                     state._fsp--;
 20384   
 
 20385  1 
                     stream_expression.add(expression473.getTree());
 20386  1 
 
 20387  2 
                     COMMA474=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5487);
 20388  1 
                     stream_COMMA.add(COMMA474);
 20389  1 
 
 20390   
 
 20391  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5489);
 20392  1 
                     expression475=expression();
 20393   
 
 20394  2 
                     state._fsp--;
 20395  1 
 
 20396  1 
                     stream_expression.add(expression475.getTree());
 20397   
 
 20398  1 
                     CLOSE_BRACE476=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5491);
 20399  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE476);
 20400   
 
 20401  1 
 
 20402   
                     // AST REWRITE
 20403  1 
                     // elements: expression, STRENDS, expression
 20404   
                     // token labels:
 20405   
                     // rule labels: retval
 20406   
                     // token list labels:
 20407   
                     // rule list labels:
 20408   
                     // wildcard labels:
 20409  2 
                     retval.tree = root_0;
 20410  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20411   
 
 20412  2 
                     root_0 = (Object)adaptor.nil();
 20413   
                     // 562:66: -> ^( STRENDS expression expression )
 20414   
                     {
 20415   
                         // com\\googlecode\\sparkleg\\Sparql.g:562:69: ^( STRENDS expression expression )
 20416  1 
                         {
 20417  2 
                         Object root_1 = (Object)adaptor.nil();
 20418  1 
                         root_1 = (Object)adaptor.becomeRoot(
 20419   
                         stream_STRENDS.nextNode()
 20420  1 
                         , root_1);
 20421  1 
 
 20422  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20423   
 
 20424  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20425  1 
 
 20426  1 
                         adaptor.addChild(root_0, root_1);
 20427  1 
                         }
 20428   
 
 20429  1 
                     }
 20430   
 
 20431  1 
 
 20432  2 
                     retval.tree = root_0;
 20433   
 
 20434   
                     }
 20435  2 
                     break;
 20436  1 
                 case 24 :
 20437   
                     // com\\googlecode\\sparkleg\\Sparql.g:563:7: STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20438  1 
                     {
 20439  1 
                     STRBEFORE477=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5509);
 20440  2 
                     stream_STRBEFORE.add(STRBEFORE477);
 20441   
 
 20442  1 
 
 20443  2 
                     OPEN_BRACE478=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5511);
 20444  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE478);
 20445   
 
 20446   
 
 20447  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5513);
 20448  1 
                     expression479=expression();
 20449   
 
 20450  1 
                     state._fsp--;
 20451   
 
 20452  1 
                     stream_expression.add(expression479.getTree());
 20453  1 
 
 20454  2 
                     COMMA480=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5515);
 20455  1 
                     stream_COMMA.add(COMMA480);
 20456  1 
 
 20457   
 
 20458  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5517);
 20459  1 
                     expression481=expression();
 20460   
 
 20461  2 
                     state._fsp--;
 20462  1 
 
 20463  1 
                     stream_expression.add(expression481.getTree());
 20464   
 
 20465  1 
                     CLOSE_BRACE482=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5519);
 20466  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE482);
 20467   
 
 20468  1 
 
 20469   
                     // AST REWRITE
 20470  1 
                     // elements: expression, expression, STRBEFORE
 20471   
                     // token labels:
 20472   
                     // rule labels: retval
 20473   
                     // token list labels:
 20474   
                     // rule list labels:
 20475   
                     // wildcard labels:
 20476  2 
                     retval.tree = root_0;
 20477  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20478   
 
 20479  2 
                     root_0 = (Object)adaptor.nil();
 20480   
                     // 563:68: -> ^( STRBEFORE expression expression )
 20481   
                     {
 20482   
                         // com\\googlecode\\sparkleg\\Sparql.g:563:71: ^( STRBEFORE expression expression )
 20483  1 
                         {
 20484  2 
                         Object root_1 = (Object)adaptor.nil();
 20485  1 
                         root_1 = (Object)adaptor.becomeRoot(
 20486   
                         stream_STRBEFORE.nextNode()
 20487  1 
                         , root_1);
 20488  1 
 
 20489  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20490   
 
 20491  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20492  1 
 
 20493  1 
                         adaptor.addChild(root_0, root_1);
 20494  1 
                         }
 20495   
 
 20496  1 
                     }
 20497   
 
 20498  1 
 
 20499  2 
                     retval.tree = root_0;
 20500   
 
 20501   
                     }
 20502  2 
                     break;
 20503  1 
                 case 25 :
 20504   
                     // com\\googlecode\\sparkleg\\Sparql.g:564:7: STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20505  1 
                     {
 20506  1 
                     STRAFTER483=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5537);
 20507  2 
                     stream_STRAFTER.add(STRAFTER483);
 20508   
 
 20509  1 
 
 20510  2 
                     OPEN_BRACE484=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5539);
 20511  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE484);
 20512   
 
 20513   
 
 20514  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5541);
 20515  1 
                     expression485=expression();
 20516   
 
 20517  1 
                     state._fsp--;
 20518   
 
 20519  1 
                     stream_expression.add(expression485.getTree());
 20520  1 
 
 20521  2 
                     COMMA486=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5543);
 20522  1 
                     stream_COMMA.add(COMMA486);
 20523  1 
 
 20524   
 
 20525  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5545);
 20526  1 
                     expression487=expression();
 20527   
 
 20528  2 
                     state._fsp--;
 20529  1 
 
 20530  1 
                     stream_expression.add(expression487.getTree());
 20531   
 
 20532  1 
                     CLOSE_BRACE488=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5547);
 20533  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE488);
 20534   
 
 20535  1 
 
 20536   
                     // AST REWRITE
 20537  1 
                     // elements: expression, expression, STRAFTER
 20538   
                     // token labels:
 20539   
                     // rule labels: retval
 20540   
                     // token list labels:
 20541   
                     // rule list labels:
 20542   
                     // wildcard labels:
 20543  2 
                     retval.tree = root_0;
 20544  1 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20545   
 
 20546  2 
                     root_0 = (Object)adaptor.nil();
 20547   
                     // 564:67: -> ^( STRAFTER expression expression )
 20548   
                     {
 20549   
                         // com\\googlecode\\sparkleg\\Sparql.g:564:70: ^( STRAFTER expression expression )
 20550  3 
                         {
 20551  4 
                         Object root_1 = (Object)adaptor.nil();
 20552  1 
                         root_1 = (Object)adaptor.becomeRoot(
 20553   
                         stream_STRAFTER.nextNode()
 20554  3 
                         , root_1);
 20555  3 
 
 20556  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20557   
 
 20558  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20559  3 
 
 20560  1 
                         adaptor.addChild(root_0, root_1);
 20561  3 
                         }
 20562   
 
 20563  3 
                     }
 20564   
 
 20565  3 
 
 20566  4 
                     retval.tree = root_0;
 20567   
 
 20568   
                     }
 20569  4 
                     break;
 20570  3 
                 case 26 :
 20571   
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE
 20572  3 
                     {
 20573  3 
                     REPLACE489=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_builtInCall5565);
 20574  6 
                     stream_REPLACE.add(REPLACE489);
 20575   
 
 20576  3 
 
 20577  6 
                     OPEN_BRACE490=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5567);
 20578  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE490);
 20579   
 
 20580  3 
 
 20581  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5569);
 20582  3 
                     expression491=expression();
 20583  3 
 
 20584  3 
                     state._fsp--;
 20585  3 
 
 20586  3 
                     stream_expression.add(expression491.getTree());
 20587  3 
 
 20588  6 
                     COMMA492=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5571);
 20589  3 
                     stream_COMMA.add(COMMA492);
 20590   
 
 20591   
 
 20592  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5573);
 20593  3 
                     expression493=expression();
 20594   
 
 20595  3 
                     state._fsp--;
 20596   
 
 20597  3 
                     stream_expression.add(expression493.getTree());
 20598  3 
 
 20599  6 
                     COMMA494=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5575);
 20600  3 
                     stream_COMMA.add(COMMA494);
 20601  3 
 
 20602   
 
 20603  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5577);
 20604  3 
                     expression495=expression();
 20605   
 
 20606  6 
                     state._fsp--;
 20607  3 
 
 20608  3 
                     stream_expression.add(expression495.getTree());
 20609   
 
 20610  3 
                     CLOSE_BRACE496=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5579);
 20611  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE496);
 20612   
 
 20613  3 
 
 20614   
                     // AST REWRITE
 20615  3 
                     // elements: expression, expression, REPLACE, expression
 20616   
                     // token labels:
 20617  3 
                     // rule labels: retval
 20618   
                     // token list labels:
 20619   
                     // rule list labels:
 20620   
                     // wildcard labels:
 20621  3 
                     retval.tree = root_0;
 20622  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20623  3 
 
 20624  3 
                     root_0 = (Object)adaptor.nil();
 20625   
                     // 565:83: -> ^( REPLACE expression expression expression )
 20626  3 
                     {
 20627   
                         // com\\googlecode\\sparkleg\\Sparql.g:565:86: ^( REPLACE expression expression expression )
 20628   
                         {
 20629  3 
                         Object root_1 = (Object)adaptor.nil();
 20630  4 
                         root_1 = (Object)adaptor.becomeRoot(
 20631  1 
                         stream_REPLACE.nextNode()
 20632   
                         , root_1);
 20633   
 
 20634  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20635  1 
 
 20636  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20637   
 
 20638  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20639  1 
 
 20640  3 
                         adaptor.addChild(root_0, root_1);
 20641  1 
                         }
 20642   
 
 20643  1 
                     }
 20644   
 
 20645  1 
 
 20646  4 
                     retval.tree = root_0;
 20647   
 
 20648   
                     }
 20649  3 
                     break;
 20650   
                 case 27 :
 20651   
                     // com\\googlecode\\sparkleg\\Sparql.g:566:7: YEAR OPEN_BRACE expression CLOSE_BRACE
 20652   
                     {
 20653  1 
                     YEAR497=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5599);
 20654  1 
                     stream_YEAR.add(YEAR497);
 20655   
 
 20656  1 
 
 20657  2 
                     OPEN_BRACE498=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5601);
 20658  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE498);
 20659  1 
 
 20660   
 
 20661  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5603);
 20662  1 
                     expression499=expression();
 20663   
 
 20664  2 
                     state._fsp--;
 20665  1 
 
 20666  1 
                     stream_expression.add(expression499.getTree());
 20667   
 
 20668  1 
                     CLOSE_BRACE500=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5605);
 20669  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE500);
 20670   
 
 20671  1 
 
 20672   
                     // AST REWRITE
 20673   
                     // elements: YEAR, expression
 20674   
                     // token labels:
 20675   
                     // rule labels: retval
 20676   
                     // token list labels:
 20677  1 
                     // rule list labels:
 20678   
                     // wildcard labels:
 20679  1 
                     retval.tree = root_0;
 20680  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20681   
 
 20682  1 
                     root_0 = (Object)adaptor.nil();
 20683   
                     // 566:46: -> ^( YEAR expression )
 20684  1 
                     {
 20685  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:566:49: ^( YEAR expression )
 20686   
                         {
 20687  1 
                         Object root_1 = (Object)adaptor.nil();
 20688  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20689  1 
                         stream_YEAR.nextNode()
 20690   
                         , root_1);
 20691   
 
 20692  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20693  1 
 
 20694  1 
                         adaptor.addChild(root_0, root_1);
 20695  1 
                         }
 20696   
 
 20697  1 
                     }
 20698   
 
 20699  1 
 
 20700  2 
                     retval.tree = root_0;
 20701   
 
 20702   
                     }
 20703  1 
                     break;
 20704   
                 case 28 :
 20705   
                     // com\\googlecode\\sparkleg\\Sparql.g:567:7: MONTH OPEN_BRACE expression CLOSE_BRACE
 20706   
                     {
 20707  1 
                     MONTH501=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5621);
 20708  1 
                     stream_MONTH.add(MONTH501);
 20709   
 
 20710  1 
 
 20711  2 
                     OPEN_BRACE502=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5623);
 20712  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE502);
 20713  1 
 
 20714   
 
 20715  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5625);
 20716  1 
                     expression503=expression();
 20717   
 
 20718  2 
                     state._fsp--;
 20719  1 
 
 20720  1 
                     stream_expression.add(expression503.getTree());
 20721   
 
 20722  1 
                     CLOSE_BRACE504=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5627);
 20723  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE504);
 20724   
 
 20725  1 
 
 20726   
                     // AST REWRITE
 20727   
                     // elements: MONTH, expression
 20728   
                     // token labels:
 20729   
                     // rule labels: retval
 20730   
                     // token list labels:
 20731  1 
                     // rule list labels:
 20732   
                     // wildcard labels:
 20733  1 
                     retval.tree = root_0;
 20734  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20735   
 
 20736  1 
                     root_0 = (Object)adaptor.nil();
 20737   
                     // 567:47: -> ^( MONTH expression )
 20738  1 
                     {
 20739  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:567:50: ^( MONTH expression )
 20740   
                         {
 20741  1 
                         Object root_1 = (Object)adaptor.nil();
 20742  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20743  1 
                         stream_MONTH.nextNode()
 20744   
                         , root_1);
 20745   
 
 20746  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20747  1 
 
 20748  1 
                         adaptor.addChild(root_0, root_1);
 20749  1 
                         }
 20750   
 
 20751  1 
                     }
 20752   
 
 20753  1 
 
 20754  2 
                     retval.tree = root_0;
 20755   
 
 20756   
                     }
 20757  1 
                     break;
 20758   
                 case 29 :
 20759   
                     // com\\googlecode\\sparkleg\\Sparql.g:568:7: DAY OPEN_BRACE expression CLOSE_BRACE
 20760   
                     {
 20761  1 
                     DAY505=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5643);
 20762  1 
                     stream_DAY.add(DAY505);
 20763   
 
 20764  1 
 
 20765  2 
                     OPEN_BRACE506=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5645);
 20766  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE506);
 20767  1 
 
 20768   
 
 20769  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5647);
 20770  1 
                     expression507=expression();
 20771   
 
 20772  2 
                     state._fsp--;
 20773  1 
 
 20774  1 
                     stream_expression.add(expression507.getTree());
 20775   
 
 20776  1 
                     CLOSE_BRACE508=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5649);
 20777  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE508);
 20778   
 
 20779  1 
 
 20780   
                     // AST REWRITE
 20781   
                     // elements: DAY, expression
 20782   
                     // token labels:
 20783   
                     // rule labels: retval
 20784   
                     // token list labels:
 20785  1 
                     // rule list labels:
 20786   
                     // wildcard labels:
 20787  1 
                     retval.tree = root_0;
 20788  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20789   
 
 20790  1 
                     root_0 = (Object)adaptor.nil();
 20791   
                     // 568:45: -> ^( DAY expression )
 20792  1 
                     {
 20793  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:568:48: ^( DAY expression )
 20794   
                         {
 20795  1 
                         Object root_1 = (Object)adaptor.nil();
 20796  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20797  1 
                         stream_DAY.nextNode()
 20798   
                         , root_1);
 20799   
 
 20800  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20801  1 
 
 20802  1 
                         adaptor.addChild(root_0, root_1);
 20803  1 
                         }
 20804   
 
 20805  1 
                     }
 20806   
 
 20807  1 
 
 20808  2 
                     retval.tree = root_0;
 20809   
 
 20810   
                     }
 20811  1 
                     break;
 20812   
                 case 30 :
 20813   
                     // com\\googlecode\\sparkleg\\Sparql.g:569:7: HOURS OPEN_BRACE expression CLOSE_BRACE
 20814   
                     {
 20815  1 
                     HOURS509=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5665);
 20816  1 
                     stream_HOURS.add(HOURS509);
 20817   
 
 20818  1 
 
 20819  2 
                     OPEN_BRACE510=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5667);
 20820  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE510);
 20821  1 
 
 20822   
 
 20823  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5669);
 20824  1 
                     expression511=expression();
 20825   
 
 20826  2 
                     state._fsp--;
 20827  1 
 
 20828  1 
                     stream_expression.add(expression511.getTree());
 20829   
 
 20830  1 
                     CLOSE_BRACE512=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5671);
 20831  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE512);
 20832   
 
 20833  1 
 
 20834   
                     // AST REWRITE
 20835   
                     // elements: expression, HOURS
 20836   
                     // token labels:
 20837   
                     // rule labels: retval
 20838   
                     // token list labels:
 20839  1 
                     // rule list labels:
 20840   
                     // wildcard labels:
 20841  1 
                     retval.tree = root_0;
 20842  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20843   
 
 20844  1 
                     root_0 = (Object)adaptor.nil();
 20845   
                     // 569:47: -> ^( HOURS expression )
 20846  1 
                     {
 20847  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:569:50: ^( HOURS expression )
 20848   
                         {
 20849  1 
                         Object root_1 = (Object)adaptor.nil();
 20850  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20851  1 
                         stream_HOURS.nextNode()
 20852   
                         , root_1);
 20853   
 
 20854  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20855  1 
 
 20856  1 
                         adaptor.addChild(root_0, root_1);
 20857  1 
                         }
 20858   
 
 20859  1 
                     }
 20860   
 
 20861  1 
 
 20862  2 
                     retval.tree = root_0;
 20863   
 
 20864   
                     }
 20865  1 
                     break;
 20866   
                 case 31 :
 20867   
                     // com\\googlecode\\sparkleg\\Sparql.g:570:7: MINUTES OPEN_BRACE expression CLOSE_BRACE
 20868   
                     {
 20869  1 
                     MINUTES513=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5687);
 20870  1 
                     stream_MINUTES.add(MINUTES513);
 20871   
 
 20872  1 
 
 20873  2 
                     OPEN_BRACE514=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5689);
 20874  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE514);
 20875  1 
 
 20876   
 
 20877  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5691);
 20878  1 
                     expression515=expression();
 20879   
 
 20880  2 
                     state._fsp--;
 20881  1 
 
 20882  1 
                     stream_expression.add(expression515.getTree());
 20883   
 
 20884  1 
                     CLOSE_BRACE516=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5693);
 20885  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE516);
 20886   
 
 20887  1 
 
 20888   
                     // AST REWRITE
 20889   
                     // elements: expression, MINUTES
 20890   
                     // token labels:
 20891   
                     // rule labels: retval
 20892   
                     // token list labels:
 20893  1 
                     // rule list labels:
 20894   
                     // wildcard labels:
 20895  1 
                     retval.tree = root_0;
 20896  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20897   
 
 20898  1 
                     root_0 = (Object)adaptor.nil();
 20899   
                     // 570:49: -> ^( MINUTES expression )
 20900  1 
                     {
 20901  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:570:52: ^( MINUTES expression )
 20902   
                         {
 20903  1 
                         Object root_1 = (Object)adaptor.nil();
 20904  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20905  1 
                         stream_MINUTES.nextNode()
 20906   
                         , root_1);
 20907   
 
 20908  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20909  1 
 
 20910  1 
                         adaptor.addChild(root_0, root_1);
 20911  1 
                         }
 20912   
 
 20913  1 
                     }
 20914   
 
 20915  1 
 
 20916  2 
                     retval.tree = root_0;
 20917   
 
 20918   
                     }
 20919  1 
                     break;
 20920   
                 case 32 :
 20921   
                     // com\\googlecode\\sparkleg\\Sparql.g:571:7: SECONDS OPEN_BRACE expression CLOSE_BRACE
 20922   
                     {
 20923  1 
                     SECONDS517=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5709);
 20924  1 
                     stream_SECONDS.add(SECONDS517);
 20925   
 
 20926  1 
 
 20927  2 
                     OPEN_BRACE518=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5711);
 20928  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE518);
 20929  1 
 
 20930   
 
 20931  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5713);
 20932  1 
                     expression519=expression();
 20933   
 
 20934  2 
                     state._fsp--;
 20935  1 
 
 20936  1 
                     stream_expression.add(expression519.getTree());
 20937   
 
 20938  1 
                     CLOSE_BRACE520=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5715);
 20939  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE520);
 20940   
 
 20941  1 
 
 20942   
                     // AST REWRITE
 20943   
                     // elements: SECONDS, expression
 20944   
                     // token labels:
 20945   
                     // rule labels: retval
 20946   
                     // token list labels:
 20947  1 
                     // rule list labels:
 20948   
                     // wildcard labels:
 20949  1 
                     retval.tree = root_0;
 20950  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20951   
 
 20952  1 
                     root_0 = (Object)adaptor.nil();
 20953   
                     // 571:49: -> ^( SECONDS expression )
 20954  1 
                     {
 20955  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:571:52: ^( SECONDS expression )
 20956   
                         {
 20957  1 
                         Object root_1 = (Object)adaptor.nil();
 20958  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20959  1 
                         stream_SECONDS.nextNode()
 20960   
                         , root_1);
 20961   
 
 20962  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20963  1 
 
 20964  1 
                         adaptor.addChild(root_0, root_1);
 20965  1 
                         }
 20966   
 
 20967  1 
                     }
 20968   
 
 20969  1 
 
 20970  2 
                     retval.tree = root_0;
 20971   
 
 20972   
                     }
 20973  1 
                     break;
 20974   
                 case 33 :
 20975   
                     // com\\googlecode\\sparkleg\\Sparql.g:572:7: TIMEZONE OPEN_BRACE expression CLOSE_BRACE
 20976   
                     {
 20977  1 
                     TIMEZONE521=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5731);
 20978  1 
                     stream_TIMEZONE.add(TIMEZONE521);
 20979   
 
 20980  1 
 
 20981  2 
                     OPEN_BRACE522=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5733);
 20982  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE522);
 20983  1 
 
 20984   
 
 20985  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5735);
 20986  1 
                     expression523=expression();
 20987   
 
 20988  2 
                     state._fsp--;
 20989  1 
 
 20990  1 
                     stream_expression.add(expression523.getTree());
 20991   
 
 20992  1 
                     CLOSE_BRACE524=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5737);
 20993  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE524);
 20994   
 
 20995  1 
 
 20996   
                     // AST REWRITE
 20997   
                     // elements: expression, TIMEZONE
 20998   
                     // token labels:
 20999   
                     // rule labels: retval
 21000   
                     // token list labels:
 21001  1 
                     // rule list labels:
 21002   
                     // wildcard labels:
 21003  1 
                     retval.tree = root_0;
 21004  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21005   
 
 21006  1 
                     root_0 = (Object)adaptor.nil();
 21007   
                     // 572:50: -> ^( TIMEZONE expression )
 21008  1 
                     {
 21009  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:572:53: ^( TIMEZONE expression )
 21010   
                         {
 21011  1 
                         Object root_1 = (Object)adaptor.nil();
 21012  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21013  1 
                         stream_TIMEZONE.nextNode()
 21014   
                         , root_1);
 21015   
 
 21016  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21017  1 
 
 21018  1 
                         adaptor.addChild(root_0, root_1);
 21019  1 
                         }
 21020   
 
 21021  1 
                     }
 21022   
 
 21023  1 
 
 21024  2 
                     retval.tree = root_0;
 21025   
 
 21026   
                     }
 21027  1 
                     break;
 21028   
                 case 34 :
 21029   
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: TZ OPEN_BRACE expression CLOSE_BRACE
 21030   
                     {
 21031  1 
                     TZ525=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5753);
 21032  1 
                     stream_TZ.add(TZ525);
 21033   
 
 21034  1 
 
 21035  2 
                     OPEN_BRACE526=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5755);
 21036  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE526);
 21037  1 
 
 21038   
 
 21039  1 
                     pushFollow(FOLLOW_expression_in_builtInCall5757);
 21040  1 
                     expression527=expression();
 21041   
 
 21042  2 
                     state._fsp--;
 21043  1 
 
 21044  1 
                     stream_expression.add(expression527.getTree());
 21045   
 
 21046  1 
                     CLOSE_BRACE528=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5759);
 21047  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE528);
 21048   
 
 21049  1 
 
 21050   
                     // AST REWRITE
 21051   
                     // elements: expression, TZ
 21052   
                     // token labels:
 21053   
                     // rule labels: retval
 21054   
                     // token list labels:
 21055  1 
                     // rule list labels:
 21056   
                     // wildcard labels:
 21057  1 
                     retval.tree = root_0;
 21058  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21059   
 
 21060  1 
                     root_0 = (Object)adaptor.nil();
 21061   
                     // 573:44: -> ^( TZ expression )
 21062  1 
                     {
 21063  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:573:47: ^( TZ expression )
 21064   
                         {
 21065  1 
                         Object root_1 = (Object)adaptor.nil();
 21066  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21067  1 
                         stream_TZ.nextNode()
 21068   
                         , root_1);
 21069  1 
 
 21070  1 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21071  1 
 
 21072  1 
                         adaptor.addChild(root_0, root_1);
 21073   
                         }
 21074   
 
 21075   
                     }
 21076   
 
 21077   
 
 21078  1 
                     retval.tree = root_0;
 21079   
 
 21080  1 
                     }
 21081  2 
                     break;
 21082   
                 case 35 :
 21083  1 
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: NOW nil
 21084   
                     {
 21085  1 
                     NOW529=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall5775);
 21086  2 
                     stream_NOW.add(NOW529);
 21087   
 
 21088   
 
 21089  1 
                     pushFollow(FOLLOW_nil_in_builtInCall5777);
 21090  1 
                     nil530=nil();
 21091   
 
 21092  1 
                     state._fsp--;
 21093  1 
 
 21094  1 
                     stream_nil.add(nil530.getTree());
 21095   
 
 21096  1 
                     // AST REWRITE
 21097   
                     // elements: NOW
 21098   
                     // token labels:
 21099   
                     // rule labels: retval
 21100  2 
                     // token list labels:
 21101  2 
                     // rule list labels:
 21102   
                     // wildcard labels:
 21103  1 
                     retval.tree = root_0;
 21104  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21105  2 
 
 21106  1 
                     root_0 = (Object)adaptor.nil();
 21107   
                     // 574:15: -> NOW
 21108  2 
                     {
 21109  3 
                         adaptor.addChild(root_0,
 21110   
                         stream_NOW.nextNode()
 21111  2 
                         );
 21112   
 
 21113  2 
                     }
 21114   
 
 21115  2 
 
 21116  3 
                     retval.tree = root_0;
 21117   
 
 21118   
                     }
 21119  1 
                     break;
 21120   
                 case 36 :
 21121   
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: MD5 OPEN_BRACE expression CLOSE_BRACE
 21122   
                     {
 21123  2 
                     MD5531=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall5789);
 21124  2 
                     stream_MD5.add(MD5531);
 21125   
 
 21126  2 
 
 21127  4 
                     OPEN_BRACE532=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5791);
 21128  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE532);
 21129  2 
 
 21130   
 
 21131  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5793);
 21132  2 
                     expression533=expression();
 21133   
 
 21134  4 
                     state._fsp--;
 21135  2 
 
 21136  2 
                     stream_expression.add(expression533.getTree());
 21137   
 
 21138  2 
                     CLOSE_BRACE534=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5795);
 21139  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE534);
 21140   
 
 21141  2 
 
 21142   
                     // AST REWRITE
 21143   
                     // elements: MD5, expression
 21144   
                     // token labels:
 21145   
                     // rule labels: retval
 21146   
                     // token list labels:
 21147  2 
                     // rule list labels:
 21148   
                     // wildcard labels:
 21149  2 
                     retval.tree = root_0;
 21150  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21151   
 
 21152  2 
                     root_0 = (Object)adaptor.nil();
 21153   
                     // 575:45: -> ^( MD5 expression )
 21154  2 
                     {
 21155  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:575:48: ^( MD5 expression )
 21156   
                         {
 21157  2 
                         Object root_1 = (Object)adaptor.nil();
 21158  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21159  2 
                         stream_MD5.nextNode()
 21160   
                         , root_1);
 21161   
 
 21162  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21163  2 
 
 21164  2 
                         adaptor.addChild(root_0, root_1);
 21165  2 
                         }
 21166   
 
 21167  2 
                     }
 21168   
 
 21169  2 
 
 21170  4 
                     retval.tree = root_0;
 21171   
 
 21172   
                     }
 21173  2 
                     break;
 21174   
                 case 37 :
 21175   
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: SHA1 OPEN_BRACE expression CLOSE_BRACE
 21176   
                     {
 21177  2 
                     SHA1535=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall5811);
 21178  2 
                     stream_SHA1.add(SHA1535);
 21179   
 
 21180  2 
 
 21181  4 
                     OPEN_BRACE536=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5813);
 21182  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE536);
 21183  2 
 
 21184   
 
 21185  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5815);
 21186  2 
                     expression537=expression();
 21187   
 
 21188  4 
                     state._fsp--;
 21189  2 
 
 21190  2 
                     stream_expression.add(expression537.getTree());
 21191   
 
 21192  2 
                     CLOSE_BRACE538=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5817);
 21193  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE538);
 21194   
 
 21195  2 
 
 21196   
                     // AST REWRITE
 21197   
                     // elements: expression, SHA1
 21198   
                     // token labels:
 21199   
                     // rule labels: retval
 21200   
                     // token list labels:
 21201  2 
                     // rule list labels:
 21202   
                     // wildcard labels:
 21203  2 
                     retval.tree = root_0;
 21204  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21205   
 
 21206  2 
                     root_0 = (Object)adaptor.nil();
 21207   
                     // 576:46: -> ^( SHA1 expression )
 21208   
                     {
 21209   
                         // com\\googlecode\\sparkleg\\Sparql.g:576:49: ^( SHA1 expression )
 21210   
                         {
 21211  2 
                         Object root_1 = (Object)adaptor.nil();
 21212  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21213   
                         stream_SHA1.nextNode()
 21214   
                         , root_1);
 21215   
 
 21216  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21217   
 
 21218  2 
                         adaptor.addChild(root_0, root_1);
 21219   
                         }
 21220   
 
 21221   
                     }
 21222   
 
 21223   
 
 21224  2 
                     retval.tree = root_0;
 21225   
 
 21226   
                     }
 21227  2 
                     break;
 21228   
                 case 38 :
 21229   
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: SHA224 OPEN_BRACE expression CLOSE_BRACE
 21230   
                     {
 21231  0 
                     SHA224539=(Token)match(input,SHA224,FOLLOW_SHA224_in_builtInCall5833);
 21232  0 
                     stream_SHA224.add(SHA224539);
 21233   
 
 21234   
 
 21235  0 
                     OPEN_BRACE540=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5835);
 21236  0 
                     stream_OPEN_BRACE.add(OPEN_BRACE540);
 21237   
 
 21238   
 
 21239  0 
                     pushFollow(FOLLOW_expression_in_builtInCall5837);
 21240  0 
                     expression541=expression();
 21241   
 
 21242  0 
                     state._fsp--;
 21243   
 
 21244  0 
                     stream_expression.add(expression541.getTree());
 21245   
 
 21246  0 
                     CLOSE_BRACE542=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5839);
 21247  0 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE542);
 21248   
 
 21249   
 
 21250   
                     // AST REWRITE
 21251   
                     // elements: expression, SHA224
 21252   
                     // token labels:
 21253   
                     // rule labels: retval
 21254   
                     // token list labels:
 21255   
                     // rule list labels:
 21256   
                     // wildcard labels:
 21257  0 
                     retval.tree = root_0;
 21258  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21259   
 
 21260  0 
                     root_0 = (Object)adaptor.nil();
 21261   
                     // 577:48: -> ^( SHA224 expression )
 21262  2 
                     {
 21263  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:577:51: ^( SHA224 expression )
 21264   
                         {
 21265  0 
                         Object root_1 = (Object)adaptor.nil();
 21266  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21267  2 
                         stream_SHA224.nextNode()
 21268   
                         , root_1);
 21269   
 
 21270  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21271  2 
 
 21272  0 
                         adaptor.addChild(root_0, root_1);
 21273  2 
                         }
 21274   
 
 21275  2 
                     }
 21276   
 
 21277  2 
 
 21278  2 
                     retval.tree = root_0;
 21279   
 
 21280   
                     }
 21281  0 
                     break;
 21282   
                 case 39 :
 21283   
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: SHA256 OPEN_BRACE expression CLOSE_BRACE
 21284   
                     {
 21285  2 
                     SHA256543=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall5855);
 21286  2 
                     stream_SHA256.add(SHA256543);
 21287   
 
 21288  2 
 
 21289  4 
                     OPEN_BRACE544=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5857);
 21290  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE544);
 21291  2 
 
 21292   
 
 21293  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5859);
 21294  2 
                     expression545=expression();
 21295   
 
 21296  4 
                     state._fsp--;
 21297  2 
 
 21298  2 
                     stream_expression.add(expression545.getTree());
 21299   
 
 21300  2 
                     CLOSE_BRACE546=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5861);
 21301  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE546);
 21302   
 
 21303  2 
 
 21304   
                     // AST REWRITE
 21305   
                     // elements: SHA256, expression
 21306   
                     // token labels:
 21307   
                     // rule labels: retval
 21308   
                     // token list labels:
 21309  2 
                     // rule list labels:
 21310   
                     // wildcard labels:
 21311  2 
                     retval.tree = root_0;
 21312  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21313   
 
 21314  2 
                     root_0 = (Object)adaptor.nil();
 21315   
                     // 578:48: -> ^( SHA256 expression )
 21316  2 
                     {
 21317  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:578:51: ^( SHA256 expression )
 21318   
                         {
 21319  2 
                         Object root_1 = (Object)adaptor.nil();
 21320  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21321  2 
                         stream_SHA256.nextNode()
 21322   
                         , root_1);
 21323   
 
 21324  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21325  2 
 
 21326  2 
                         adaptor.addChild(root_0, root_1);
 21327  2 
                         }
 21328   
 
 21329  2 
                     }
 21330   
 
 21331  2 
 
 21332  4 
                     retval.tree = root_0;
 21333   
 
 21334   
                     }
 21335  2 
                     break;
 21336   
                 case 40 :
 21337   
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: SHA384 OPEN_BRACE expression CLOSE_BRACE
 21338   
                     {
 21339  2 
                     SHA384547=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall5877);
 21340  2 
                     stream_SHA384.add(SHA384547);
 21341   
 
 21342  2 
 
 21343  4 
                     OPEN_BRACE548=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5879);
 21344  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE548);
 21345  2 
 
 21346   
 
 21347  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5881);
 21348  2 
                     expression549=expression();
 21349   
 
 21350  4 
                     state._fsp--;
 21351  2 
 
 21352  2 
                     stream_expression.add(expression549.getTree());
 21353   
 
 21354  2 
                     CLOSE_BRACE550=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5883);
 21355  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE550);
 21356   
 
 21357  2 
 
 21358   
                     // AST REWRITE
 21359   
                     // elements: expression, SHA384
 21360   
                     // token labels:
 21361   
                     // rule labels: retval
 21362   
                     // token list labels:
 21363  2 
                     // rule list labels:
 21364   
                     // wildcard labels:
 21365  2 
                     retval.tree = root_0;
 21366  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21367   
 
 21368  2 
                     root_0 = (Object)adaptor.nil();
 21369   
                     // 579:48: -> ^( SHA384 expression )
 21370  2 
                     {
 21371  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:579:51: ^( SHA384 expression )
 21372   
                         {
 21373  2 
                         Object root_1 = (Object)adaptor.nil();
 21374  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21375  2 
                         stream_SHA384.nextNode()
 21376   
                         , root_1);
 21377   
 
 21378  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21379  2 
 
 21380  2 
                         adaptor.addChild(root_0, root_1);
 21381  2 
                         }
 21382   
 
 21383  2 
                     }
 21384   
 
 21385  2 
 
 21386  4 
                     retval.tree = root_0;
 21387   
 
 21388   
                     }
 21389  2 
                     break;
 21390   
                 case 41 :
 21391   
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: SHA512 OPEN_BRACE expression CLOSE_BRACE
 21392   
                     {
 21393  2 
                     SHA512551=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall5899);
 21394  2 
                     stream_SHA512.add(SHA512551);
 21395   
 
 21396  2 
 
 21397  4 
                     OPEN_BRACE552=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5901);
 21398  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE552);
 21399  2 
 
 21400   
 
 21401  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5903);
 21402  2 
                     expression553=expression();
 21403   
 
 21404  4 
                     state._fsp--;
 21405  2 
 
 21406  2 
                     stream_expression.add(expression553.getTree());
 21407   
 
 21408  2 
                     CLOSE_BRACE554=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5905);
 21409  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE554);
 21410   
 
 21411  2 
 
 21412   
                     // AST REWRITE
 21413   
                     // elements: SHA512, expression
 21414   
                     // token labels:
 21415   
                     // rule labels: retval
 21416   
                     // token list labels:
 21417  2 
                     // rule list labels:
 21418   
                     // wildcard labels:
 21419  2 
                     retval.tree = root_0;
 21420  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21421   
 
 21422  2 
                     root_0 = (Object)adaptor.nil();
 21423   
                     // 580:48: -> ^( SHA512 expression )
 21424  6 
                     {
 21425  6 
                         // com\\googlecode\\sparkleg\\Sparql.g:580:51: ^( SHA512 expression )
 21426   
                         {
 21427  2 
                         Object root_1 = (Object)adaptor.nil();
 21428  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21429  6 
                         stream_SHA512.nextNode()
 21430   
                         , root_1);
 21431  6 
 
 21432  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21433  6 
 
 21434  2 
                         adaptor.addChild(root_0, root_1);
 21435   
                         }
 21436   
 
 21437   
                     }
 21438   
 
 21439   
 
 21440  2 
                     retval.tree = root_0;
 21441   
 
 21442  6 
                     }
 21443  8 
                     break;
 21444   
                 case 42 :
 21445  6 
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: COALESCE expressionList
 21446   
                     {
 21447  6 
                     COALESCE555=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall5921);
 21448  6 
                     stream_COALESCE.add(COALESCE555);
 21449   
 
 21450  6 
 
 21451  12 
                     pushFollow(FOLLOW_expressionList_in_builtInCall5923);
 21452  6 
                     expressionList556=expressionList();
 21453   
 
 21454  6 
                     state._fsp--;
 21455  6 
 
 21456  6 
                     stream_expressionList.add(expressionList556.getTree());
 21457  6 
 
 21458   
                     // AST REWRITE
 21459   
                     // elements: expressionList, COALESCE
 21460   
                     // token labels:
 21461   
                     // rule labels: retval
 21462   
                     // token list labels:
 21463  6 
                     // rule list labels:
 21464   
                     // wildcard labels:
 21465  6 
                     retval.tree = root_0;
 21466  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21467   
 
 21468  6 
                     root_0 = (Object)adaptor.nil();
 21469   
                     // 581:31: -> ^( COALESCE expressionList )
 21470  3 
                     {
 21471  3 
                         // com\\googlecode\\sparkleg\\Sparql.g:581:34: ^( COALESCE expressionList )
 21472   
                         {
 21473  6 
                         Object root_1 = (Object)adaptor.nil();
 21474  9 
                         root_1 = (Object)adaptor.becomeRoot(
 21475  3 
                         stream_COALESCE.nextNode()
 21476   
                         , root_1);
 21477   
 
 21478  9 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21479  3 
 
 21480  6 
                         adaptor.addChild(root_0, root_1);
 21481  3 
                         }
 21482   
 
 21483  3 
                     }
 21484   
 
 21485  3 
 
 21486  9 
                     retval.tree = root_0;
 21487   
 
 21488   
                     }
 21489  9 
                     break;
 21490  3 
                 case 43 :
 21491   
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE
 21492  3 
                     {
 21493  3 
                     IF557=(Token)match(input,IF,FOLLOW_IF_in_builtInCall5939);
 21494  6 
                     stream_IF.add(IF557);
 21495   
 
 21496  3 
 
 21497  6 
                     OPEN_BRACE558=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5941);
 21498  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE558);
 21499   
 
 21500  3 
 
 21501  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5945);
 21502  3 
                     e1=expression();
 21503  3 
 
 21504  3 
                     state._fsp--;
 21505  3 
 
 21506  3 
                     stream_expression.add(e1.getTree());
 21507  3 
 
 21508  6 
                     COMMA559=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5947);
 21509  3 
                     stream_COMMA.add(COMMA559);
 21510   
 
 21511   
 
 21512  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5951);
 21513  3 
                     e2=expression();
 21514   
 
 21515  3 
                     state._fsp--;
 21516   
 
 21517  3 
                     stream_expression.add(e2.getTree());
 21518  3 
 
 21519  6 
                     COMMA560=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5953);
 21520  6 
                     stream_COMMA.add(COMMA560);
 21521  3 
 
 21522  3 
 
 21523  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5957);
 21524  6 
                     e3=expression();
 21525   
 
 21526  3 
                     state._fsp--;
 21527   
 
 21528  3 
                     stream_expression.add(e3.getTree());
 21529  3 
 
 21530  6 
                     CLOSE_BRACE561=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5959);
 21531  3 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE561);
 21532   
 
 21533   
 
 21534  3 
                     // AST REWRITE
 21535   
                     // elements: e2, e1, IF, e3
 21536  3 
                     // token labels:
 21537   
                     // rule labels: e3, retval, e1, e2
 21538  3 
                     // token list labels:
 21539   
                     // rule list labels:
 21540  3 
                     // wildcard labels:
 21541  3 
                     retval.tree = root_0;
 21542  3 
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21543  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21544  3 
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21545  3 
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21546  3 
 
 21547  3 
                     root_0 = (Object)adaptor.nil();
 21548   
                     // 582:87: -> ^( IF $e1 $e2 $e3)
 21549  3 
                     {
 21550   
                         // com\\googlecode\\sparkleg\\Sparql.g:582:90: ^( IF $e1 $e2 $e3)
 21551   
                         {
 21552  3 
                         Object root_1 = (Object)adaptor.nil();
 21553  6 
                         root_1 = (Object)adaptor.becomeRoot(
 21554  3 
                         stream_IF.nextNode()
 21555   
                         , root_1);
 21556   
 
 21557  6 
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21558  3 
 
 21559  3 
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21560   
 
 21561  6 
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21562  3 
 
 21563  3 
                         adaptor.addChild(root_0, root_1);
 21564  3 
                         }
 21565   
 
 21566  3 
                     }
 21567   
 
 21568  3 
 
 21569  6 
                     retval.tree = root_0;
 21570   
 
 21571   
                     }
 21572  6 
                     break;
 21573  3 
                 case 44 :
 21574   
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21575  3 
                     {
 21576  3 
                     STRLANG562=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall5982);
 21577  6 
                     stream_STRLANG.add(STRLANG562);
 21578   
 
 21579  3 
 
 21580  6 
                     OPEN_BRACE563=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5984);
 21581  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE563);
 21582   
 
 21583   
 
 21584  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5986);
 21585  3 
                     expression564=expression();
 21586   
 
 21587  3 
                     state._fsp--;
 21588   
 
 21589  3 
                     stream_expression.add(expression564.getTree());
 21590  3 
 
 21591  6 
                     COMMA565=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5988);
 21592  3 
                     stream_COMMA.add(COMMA565);
 21593  3 
 
 21594   
 
 21595  3 
                     pushFollow(FOLLOW_expression_in_builtInCall5990);
 21596  3 
                     expression566=expression();
 21597   
 
 21598  6 
                     state._fsp--;
 21599  3 
 
 21600  3 
                     stream_expression.add(expression566.getTree());
 21601   
 
 21602  3 
                     CLOSE_BRACE567=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5992);
 21603  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE567);
 21604   
 
 21605  3 
 
 21606   
                     // AST REWRITE
 21607  3 
                     // elements: expression, expression, STRLANG
 21608   
                     // token labels:
 21609   
                     // rule labels: retval
 21610   
                     // token list labels:
 21611   
                     // rule list labels:
 21612   
                     // wildcard labels:
 21613  6 
                     retval.tree = root_0;
 21614  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21615   
 
 21616  6 
                     root_0 = (Object)adaptor.nil();
 21617   
                     // 583:66: -> ^( STRLANG expression expression )
 21618   
                     {
 21619   
                         // com\\googlecode\\sparkleg\\Sparql.g:583:69: ^( STRLANG expression expression )
 21620  3 
                         {
 21621  6 
                         Object root_1 = (Object)adaptor.nil();
 21622  3 
                         root_1 = (Object)adaptor.becomeRoot(
 21623   
                         stream_STRLANG.nextNode()
 21624  3 
                         , root_1);
 21625  3 
 
 21626  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21627   
 
 21628  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21629  3 
 
 21630  3 
                         adaptor.addChild(root_0, root_1);
 21631  3 
                         }
 21632   
 
 21633  3 
                     }
 21634   
 
 21635  3 
 
 21636  6 
                     retval.tree = root_0;
 21637   
 
 21638   
                     }
 21639  6 
                     break;
 21640  3 
                 case 45 :
 21641   
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21642  3 
                     {
 21643  3 
                     STRDT568=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6010);
 21644  6 
                     stream_STRDT.add(STRDT568);
 21645   
 
 21646  3 
 
 21647  6 
                     OPEN_BRACE569=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6012);
 21648  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE569);
 21649   
 
 21650   
 
 21651  3 
                     pushFollow(FOLLOW_expression_in_builtInCall6014);
 21652  3 
                     expression570=expression();
 21653   
 
 21654  3 
                     state._fsp--;
 21655   
 
 21656  3 
                     stream_expression.add(expression570.getTree());
 21657  3 
 
 21658  6 
                     COMMA571=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6016);
 21659  3 
                     stream_COMMA.add(COMMA571);
 21660  3 
 
 21661   
 
 21662  3 
                     pushFollow(FOLLOW_expression_in_builtInCall6018);
 21663  3 
                     expression572=expression();
 21664   
 
 21665  6 
                     state._fsp--;
 21666  3 
 
 21667  3 
                     stream_expression.add(expression572.getTree());
 21668   
 
 21669  3 
                     CLOSE_BRACE573=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6020);
 21670  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE573);
 21671   
 
 21672  3 
 
 21673   
                     // AST REWRITE
 21674  3 
                     // elements: STRDT, expression, expression
 21675   
                     // token labels:
 21676   
                     // rule labels: retval
 21677   
                     // token list labels:
 21678   
                     // rule list labels:
 21679   
                     // wildcard labels:
 21680  6 
                     retval.tree = root_0;
 21681  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21682   
 
 21683  6 
                     root_0 = (Object)adaptor.nil();
 21684   
                     // 584:64: -> ^( STRDT expression expression )
 21685   
                     {
 21686   
                         // com\\googlecode\\sparkleg\\Sparql.g:584:67: ^( STRDT expression expression )
 21687  15 
                         {
 21688  18 
                         Object root_1 = (Object)adaptor.nil();
 21689  3 
                         root_1 = (Object)adaptor.becomeRoot(
 21690   
                         stream_STRDT.nextNode()
 21691  15 
                         , root_1);
 21692  15 
 
 21693  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21694   
 
 21695  18 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21696  15 
 
 21697  3 
                         adaptor.addChild(root_0, root_1);
 21698  15 
                         }
 21699   
 
 21700  15 
                     }
 21701   
 
 21702  15 
 
 21703  18 
                     retval.tree = root_0;
 21704   
 
 21705   
                     }
 21706  18 
                     break;
 21707  15 
                 case 46 :
 21708   
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21709  15 
                     {
 21710  15 
                     SAMETERM574=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6038);
 21711  30 
                     stream_SAMETERM.add(SAMETERM574);
 21712   
 
 21713  15 
 
 21714  30 
                     OPEN_BRACE575=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6040);
 21715  15 
                     stream_OPEN_BRACE.add(OPEN_BRACE575);
 21716   
 
 21717   
 
 21718  15 
                     pushFollow(FOLLOW_expression_in_builtInCall6042);
 21719  15 
                     expression576=expression();
 21720   
 
 21721  15 
                     state._fsp--;
 21722   
 
 21723  15 
                     stream_expression.add(expression576.getTree());
 21724  15 
 
 21725  30 
                     COMMA577=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6044);
 21726  15 
                     stream_COMMA.add(COMMA577);
 21727  15 
 
 21728   
 
 21729  15 
                     pushFollow(FOLLOW_expression_in_builtInCall6046);
 21730  15 
                     expression578=expression();
 21731   
 
 21732  30 
                     state._fsp--;
 21733  15 
 
 21734  15 
                     stream_expression.add(expression578.getTree());
 21735   
 
 21736  15 
                     CLOSE_BRACE579=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6048);
 21737  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE579);
 21738   
 
 21739  15 
 
 21740   
                     // AST REWRITE
 21741  15 
                     // elements: expression, expression, SAMETERM
 21742   
                     // token labels:
 21743   
                     // rule labels: retval
 21744   
                     // token list labels:
 21745   
                     // rule list labels:
 21746   
                     // wildcard labels:
 21747  30 
                     retval.tree = root_0;
 21748  15 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21749   
 
 21750  30 
                     root_0 = (Object)adaptor.nil();
 21751   
                     // 585:67: -> ^( SAMETERM expression expression )
 21752   
                     {
 21753   
                         // com\\googlecode\\sparkleg\\Sparql.g:585:70: ^( SAMETERM expression expression )
 21754  4 
                         {
 21755  19 
                         Object root_1 = (Object)adaptor.nil();
 21756  15 
                         root_1 = (Object)adaptor.becomeRoot(
 21757   
                         stream_SAMETERM.nextNode()
 21758  4 
                         , root_1);
 21759  4 
 
 21760  15 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21761   
 
 21762  19 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21763  4 
 
 21764  15 
                         adaptor.addChild(root_0, root_1);
 21765  4 
                         }
 21766   
 
 21767  4 
                     }
 21768   
 
 21769  4 
 
 21770  19 
                     retval.tree = root_0;
 21771   
 
 21772   
                     }
 21773  15 
                     break;
 21774   
                 case 47 :
 21775   
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: ISIRI OPEN_BRACE expression CLOSE_BRACE
 21776   
                     {
 21777  4 
                     ISIRI580=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6066);
 21778  4 
                     stream_ISIRI.add(ISIRI580);
 21779   
 
 21780  4 
 
 21781  8 
                     OPEN_BRACE581=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6068);
 21782  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE581);
 21783  4 
 
 21784   
 
 21785  4 
                     pushFollow(FOLLOW_expression_in_builtInCall6070);
 21786  4 
                     expression582=expression();
 21787   
 
 21788  8 
                     state._fsp--;
 21789  4 
 
 21790  4 
                     stream_expression.add(expression582.getTree());
 21791   
 
 21792  4 
                     CLOSE_BRACE583=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6072);
 21793  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE583);
 21794   
 
 21795  4 
 
 21796   
                     // AST REWRITE
 21797   
                     // elements: expression, ISIRI
 21798   
                     // token labels:
 21799   
                     // rule labels: retval
 21800   
                     // token list labels:
 21801  4 
                     // rule list labels:
 21802   
                     // wildcard labels:
 21803  4 
                     retval.tree = root_0;
 21804  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21805   
 
 21806  4 
                     root_0 = (Object)adaptor.nil();
 21807   
                     // 586:47: -> ^( ISIRI expression )
 21808  1 
                     {
 21809  1 
                         // com\\googlecode\\sparkleg\\Sparql.g:586:50: ^( ISIRI expression )
 21810   
                         {
 21811  4 
                         Object root_1 = (Object)adaptor.nil();
 21812  5 
                         root_1 = (Object)adaptor.becomeRoot(
 21813  1 
                         stream_ISIRI.nextNode()
 21814   
                         , root_1);
 21815   
 
 21816  5 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21817  1 
 
 21818  4 
                         adaptor.addChild(root_0, root_1);
 21819  1 
                         }
 21820   
 
 21821  1 
                     }
 21822   
 
 21823  1 
 
 21824  5 
                     retval.tree = root_0;
 21825   
 
 21826   
                     }
 21827  4 
                     break;
 21828   
                 case 48 :
 21829   
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: ISURI OPEN_BRACE expression CLOSE_BRACE
 21830   
                     {
 21831  1 
                     ISURI584=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6088);
 21832  1 
                     stream_ISURI.add(ISURI584);
 21833   
 
 21834  1 
 
 21835  2 
                     OPEN_BRACE585=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6090);
 21836  1 
                     stream_OPEN_BRACE.add(OPEN_BRACE585);
 21837  1 
 
 21838   
 
 21839  1 
                     pushFollow(FOLLOW_expression_in_builtInCall6092);
 21840  1 
                     expression586=expression();
 21841   
 
 21842  2 
                     state._fsp--;
 21843  1 
 
 21844  1 
                     stream_expression.add(expression586.getTree());
 21845   
 
 21846  1 
                     CLOSE_BRACE587=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6094);
 21847  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE587);
 21848   
 
 21849  1 
 
 21850   
                     // AST REWRITE
 21851   
                     // elements: expression, ISURI
 21852   
                     // token labels:
 21853   
                     // rule labels: retval
 21854   
                     // token list labels:
 21855  1 
                     // rule list labels:
 21856   
                     // wildcard labels:
 21857  1 
                     retval.tree = root_0;
 21858  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21859   
 
 21860  1 
                     root_0 = (Object)adaptor.nil();
 21861   
                     // 587:47: -> ^( ISURI expression )
 21862  4 
                     {
 21863  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:587:50: ^( ISURI expression )
 21864   
                         {
 21865  1 
                         Object root_1 = (Object)adaptor.nil();
 21866  5 
                         root_1 = (Object)adaptor.becomeRoot(
 21867  4 
                         stream_ISURI.nextNode()
 21868   
                         , root_1);
 21869   
 
 21870  5 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21871  4 
 
 21872  1 
                         adaptor.addChild(root_0, root_1);
 21873  4 
                         }
 21874   
 
 21875  4 
                     }
 21876   
 
 21877  4 
 
 21878  5 
                     retval.tree = root_0;
 21879   
 
 21880   
                     }
 21881  1 
                     break;
 21882   
                 case 49 :
 21883   
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: ISBLANK OPEN_BRACE expression CLOSE_BRACE
 21884   
                     {
 21885  4 
                     ISBLANK588=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6110);
 21886  4 
                     stream_ISBLANK.add(ISBLANK588);
 21887   
 
 21888  4 
 
 21889  8 
                     OPEN_BRACE589=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6112);
 21890  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE589);
 21891  4 
 
 21892   
 
 21893  4 
                     pushFollow(FOLLOW_expression_in_builtInCall6114);
 21894  4 
                     expression590=expression();
 21895   
 
 21896  8 
                     state._fsp--;
 21897  4 
 
 21898  4 
                     stream_expression.add(expression590.getTree());
 21899   
 
 21900  4 
                     CLOSE_BRACE591=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6116);
 21901  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE591);
 21902   
 
 21903  4 
 
 21904   
                     // AST REWRITE
 21905   
                     // elements: expression, ISBLANK
 21906   
                     // token labels:
 21907   
                     // rule labels: retval
 21908   
                     // token list labels:
 21909  4 
                     // rule list labels:
 21910   
                     // wildcard labels:
 21911  4 
                     retval.tree = root_0;
 21912  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21913   
 
 21914  4 
                     root_0 = (Object)adaptor.nil();
 21915   
                     // 588:49: -> ^( ISBLANK expression )
 21916  4 
                     {
 21917  4 
                         // com\\googlecode\\sparkleg\\Sparql.g:588:52: ^( ISBLANK expression )
 21918   
                         {
 21919  4 
                         Object root_1 = (Object)adaptor.nil();
 21920  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21921  4 
                         stream_ISBLANK.nextNode()
 21922   
                         , root_1);
 21923   
 
 21924  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21925  4 
 
 21926  4 
                         adaptor.addChild(root_0, root_1);
 21927  4 
                         }
 21928   
 
 21929  4 
                     }
 21930   
 
 21931  4 
 
 21932  8 
                     retval.tree = root_0;
 21933   
 
 21934   
                     }
 21935  4 
                     break;
 21936   
                 case 50 :
 21937   
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: ISLITERAL OPEN_BRACE expression CLOSE_BRACE
 21938   
                     {
 21939  4 
                     ISLITERAL592=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6133);
 21940  4 
                     stream_ISLITERAL.add(ISLITERAL592);
 21941   
 
 21942  4 
 
 21943  8 
                     OPEN_BRACE593=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6135);
 21944  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE593);
 21945  4 
 
 21946   
 
 21947  4 
                     pushFollow(FOLLOW_expression_in_builtInCall6137);
 21948  4 
                     expression594=expression();
 21949   
 
 21950  8 
                     state._fsp--;
 21951  4 
 
 21952  4 
                     stream_expression.add(expression594.getTree());
 21953   
 
 21954  4 
                     CLOSE_BRACE595=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6139);
 21955  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE595);
 21956   
 
 21957  4 
 
 21958   
                     // AST REWRITE
 21959   
                     // elements: expression, ISLITERAL
 21960   
                     // token labels:
 21961   
                     // rule labels: retval
 21962   
                     // token list labels:
 21963  4 
                     // rule list labels:
 21964   
                     // wildcard labels:
 21965  4 
                     retval.tree = root_0;
 21966  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21967   
 
 21968  4 
                     root_0 = (Object)adaptor.nil();
 21969   
                     // 589:51: -> ^( ISLITERAL expression )
 21970  2 
                     {
 21971  2 
                         // com\\googlecode\\sparkleg\\Sparql.g:589:54: ^( ISLITERAL expression )
 21972   
                         {
 21973  4 
                         Object root_1 = (Object)adaptor.nil();
 21974  6 
                         root_1 = (Object)adaptor.becomeRoot(
 21975  2 
                         stream_ISLITERAL.nextNode()
 21976   
                         , root_1);
 21977   
 
 21978  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21979  2 
 
 21980  4 
                         adaptor.addChild(root_0, root_1);
 21981  2 
                         }
 21982   
 
 21983  2 
                     }
 21984   
 
 21985  2 
 
 21986  6 
                     retval.tree = root_0;
 21987   
 
 21988   
                     }
 21989  4 
                     break;
 21990   
                 case 51 :
 21991   
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: ISNUMERIC OPEN_BRACE expression CLOSE_BRACE
 21992   
                     {
 21993  2 
                     ISNUMERIC596=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6155);
 21994  2 
                     stream_ISNUMERIC.add(ISNUMERIC596);
 21995   
 
 21996  2 
 
 21997  4 
                     OPEN_BRACE597=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6157);
 21998  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE597);
 21999  2 
 
 22000   
 
 22001  2 
                     pushFollow(FOLLOW_expression_in_builtInCall6159);
 22002  2 
                     expression598=expression();
 22003   
 
 22004  4 
                     state._fsp--;
 22005  2 
 
 22006  2 
                     stream_expression.add(expression598.getTree());
 22007   
 
 22008  2 
                     CLOSE_BRACE599=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6161);
 22009  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE599);
 22010   
 
 22011  2 
 
 22012   
                     // AST REWRITE
 22013   
                     // elements: expression, ISNUMERIC
 22014   
                     // token labels:
 22015   
                     // rule labels: retval
 22016   
                     // token list labels:
 22017  2 
                     // rule list labels:
 22018   
                     // wildcard labels:
 22019  2 
                     retval.tree = root_0;
 22020  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22021   
 
 22022  2 
                     root_0 = (Object)adaptor.nil();
 22023   
                     // 590:51: -> ^( ISNUMERIC expression )
 22024  21 
                     {
 22025  21 
                         // com\\googlecode\\sparkleg\\Sparql.g:590:54: ^( ISNUMERIC expression )
 22026   
                         {
 22027  23 
                         Object root_1 = (Object)adaptor.nil();
 22028  2 
                         root_1 = (Object)adaptor.becomeRoot(
 22029  21 
                         stream_ISNUMERIC.nextNode()
 22030   
                         , root_1);
 22031   
 
 22032  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22033   
 
 22034  2 
                         adaptor.addChild(root_0, root_1);
 22035   
                         }
 22036   
 
 22037   
                     }
 22038  21 
 
 22039  21 
 
 22040  2 
                     retval.tree = root_0;
 22041  21 
 
 22042   
                     }
 22043  2 
                     break;
 22044  21 
                 case 52 :
 22045   
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: regexExpression
 22046   
                     {
 22047  21 
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6177);
 22048  21 
                     regexExpression600=regexExpression();
 22049  21 
 
 22050  21 
                     state._fsp--;
 22051   
 
 22052  42 
                     stream_regexExpression.add(regexExpression600.getTree());
 22053   
 
 22054   
                     // AST REWRITE
 22055   
                     // elements: regexExpression
 22056  10 
                     // token labels:
 22057  10 
                     // rule labels: retval
 22058   
                     // token list labels:
 22059  10 
                     // rule list labels:
 22060   
                     // wildcard labels:
 22061  31 
                     retval.tree = root_0;
 22062  21 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22063   
 
 22064  21 
                     root_0 = (Object)adaptor.nil();
 22065   
                     // 591:23: -> regexExpression
 22066   
                     {
 22067  21 
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22068   
 
 22069   
                     }
 22070  10 
 
 22071  10 
 
 22072  21 
                     retval.tree = root_0;
 22073  10 
 
 22074   
                     }
 22075  21 
                     break;
 22076  10 
                 case 53 :
 22077   
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: existsFunction
 22078   
                     {
 22079  10 
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6189);
 22080  10 
                     existsFunction601=existsFunction();
 22081  10 
 
 22082  10 
                     state._fsp--;
 22083   
 
 22084  20 
                     stream_existsFunction.add(existsFunction601.getTree());
 22085   
 
 22086   
                     // AST REWRITE
 22087   
                     // elements: existsFunction
 22088  23 
                     // token labels:
 22089  23 
                     // rule labels: retval
 22090   
                     // token list labels:
 22091  23 
                     // rule list labels:
 22092   
                     // wildcard labels:
 22093  33 
                     retval.tree = root_0;
 22094  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22095   
 
 22096  10 
                     root_0 = (Object)adaptor.nil();
 22097   
                     // 592:22: -> existsFunction
 22098   
                     {
 22099  10 
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22100   
 
 22101   
                     }
 22102  23 
 
 22103  23 
 
 22104  10 
                     retval.tree = root_0;
 22105  23 
 
 22106   
                     }
 22107  10 
                     break;
 22108  23 
                 case 54 :
 22109   
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: notExistsFunction
 22110   
                     {
 22111  23 
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6201);
 22112  23 
                     notExistsFunction602=notExistsFunction();
 22113  23 
 
 22114  23 
                     state._fsp--;
 22115   
 
 22116  23 
                     stream_notExistsFunction.add(notExistsFunction602.getTree());
 22117   
 
 22118   
                     // AST REWRITE
 22119  266 
                     // elements: notExistsFunction
 22120   
                     // token labels:
 22121   
                     // rule labels: retval
 22122  266 
                     // token list labels:
 22123  266 
                     // rule list labels:
 22124   
                     // wildcard labels:
 22125  23 
                     retval.tree = root_0;
 22126  23 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22127   
 
 22128  23 
                     root_0 = (Object)adaptor.nil();
 22129   
                     // 593:25: -> notExistsFunction
 22130   
                     {
 22131  23 
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22132   
 
 22133   
                     }
 22134   
 
 22135  266 
 
 22136  289 
                     retval.tree = root_0;
 22137   
 
 22138   
                     }
 22139   
                     break;
 22140   
 
 22141  21 
             }
 22142  266 
             retval.stop = input.LT(-1);
 22143  21 
 
 22144   
 
 22145  266 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22146  266 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22147   
 
 22148   
         }
 22149  0 
         catch (RecognitionException re) {
 22150  21 
             reportError(re);
 22151  21 
             recover(input,re);
 22152  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22153   
 
 22154  21 
         }
 22155   
 
 22156  21 
         finally {
 22157  21 
                 // do for sure before leaving
 22158  287 
         }
 22159  287 
         return retval;
 22160  21 
     }
 22161  21 
     // $ANTLR end "builtInCall"
 22162   
 
 22163  21 
 
 22164  21 
     public static class regexExpression_return extends ParserRuleReturnScope {
 22165  21 
         Object tree;
 22166  21 
         public Object getTree() { return tree; }
 22167   
     };
 22168  21 
 
 22169  21 
 
 22170  21 
     // $ANTLR start "regexExpression"
 22171  21 
     // com\\googlecode\\sparkleg\\Sparql.g:596:1: regexExpression : REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) ;
 22172  21 
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22173  42 
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22174  42 
         retval.start = input.LT(1);
 22175  21 
 
 22176  21 
 
 22177  42 
         Object root_0 = null;
 22178   
 
 22179  21 
         Token REGEX603=null;
 22180  21 
         Token OPEN_BRACE604=null;
 22181  21 
         Token COMMA606=null;
 22182  42 
         Token COMMA608=null;
 22183  42 
         Token CLOSE_BRACE610=null;
 22184  21 
         SparqlParser.expression_return expression605 =null;
 22185   
 
 22186  42 
         SparqlParser.expression_return expression607 =null;
 22187  21 
 
 22188  21 
         SparqlParser.expression_return expression609 =null;
 22189   
 
 22190  21 
 
 22191  42 
         Object REGEX603_tree=null;
 22192  21 
         Object OPEN_BRACE604_tree=null;
 22193  42 
         Object COMMA606_tree=null;
 22194  21 
         Object COMMA608_tree=null;
 22195  42 
         Object CLOSE_BRACE610_tree=null;
 22196  21 
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22197  42 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22198  42 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22199  21 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22200  21 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22201  21 
         try {
 22202  21 
             // com\\googlecode\\sparkleg\\Sparql.g:597:5: ( REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) )
 22203   
             // com\\googlecode\\sparkleg\\Sparql.g:597:7: REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22204  21 
             {
 22205  21 
             REGEX603=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6222);
 22206  42 
             stream_REGEX.add(REGEX603);
 22207   
 
 22208   
 
 22209  42 
             OPEN_BRACE604=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_regexExpression6224);
 22210  42 
             stream_OPEN_BRACE.add(OPEN_BRACE604);
 22211   
 
 22212   
 
 22213  27 
             pushFollow(FOLLOW_expression_in_regexExpression6226);
 22214  21 
             expression605=expression();
 22215   
 
 22216  21 
             state._fsp--;
 22217   
 
 22218  42 
             stream_expression.add(expression605.getTree());
 22219   
 
 22220  21 
             COMMA606=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6228);
 22221  21 
             stream_COMMA.add(COMMA606);
 22222  6 
 
 22223  6 
 
 22224  21 
             pushFollow(FOLLOW_expression_in_regexExpression6230);
 22225  21 
             expression607=expression();
 22226  6 
 
 22227  27 
             state._fsp--;
 22228   
 
 22229  27 
             stream_expression.add(expression607.getTree());
 22230   
 
 22231  6 
             // com\\googlecode\\sparkleg\\Sparql.g:597:52: ( COMMA expression )?
 22232  21 
             int alt127=2;
 22233  21 
             switch ( input.LA(1) ) {
 22234   
                 case COMMA:
 22235   
                     {
 22236  6 
                     alt127=1;
 22237   
                     }
 22238   
                     break;
 22239  21 
             }
 22240  21 
 
 22241  21 
             switch (alt127) {
 22242   
                 case 1 :
 22243   
                     // com\\googlecode\\sparkleg\\Sparql.g:597:53: COMMA expression
 22244   
                     {
 22245  6 
                     COMMA608=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6233);
 22246  6 
                     stream_COMMA.add(COMMA608);
 22247   
 
 22248   
 
 22249  6 
                     pushFollow(FOLLOW_expression_in_regexExpression6235);
 22250  27 
                     expression609=expression();
 22251  21 
 
 22252  6 
                     state._fsp--;
 22253  21 
 
 22254  6 
                     stream_expression.add(expression609.getTree());
 22255   
 
 22256   
                     }
 22257   
                     break;
 22258  21 
 
 22259  21 
             }
 22260   
 
 22261   
 
 22262  21 
             CLOSE_BRACE610=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_regexExpression6239);
 22263  21 
             stream_CLOSE_BRACE.add(CLOSE_BRACE610);
 22264  69 
 
 22265  48 
 
 22266   
             // AST REWRITE
 22267   
             // elements: REGEX, expression
 22268  21 
             // token labels:
 22269   
             // rule labels: retval
 22270  21 
             // token list labels:
 22271   
             // rule list labels:
 22272   
             // wildcard labels:
 22273  21 
             retval.tree = root_0;
 22274  21 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22275   
 
 22276  42 
             root_0 = (Object)adaptor.nil();
 22277   
             // 597:84: -> ^( REGEX ( expression )* )
 22278   
             {
 22279   
                 // com\\googlecode\\sparkleg\\Sparql.g:597:87: ^( REGEX ( expression )* )
 22280  21 
                 {
 22281  21 
                 Object root_1 = (Object)adaptor.nil();
 22282  21 
                 root_1 = (Object)adaptor.becomeRoot(
 22283  21 
                 stream_REGEX.nextNode()
 22284  21 
                 , root_1);
 22285   
 
 22286   
                 // com\\googlecode\\sparkleg\\Sparql.g:597:95: ( expression )*
 22287  69 
                 while ( stream_expression.hasNext() ) {
 22288  48 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22289   
 
 22290   
                 }
 22291  21 
                 stream_expression.reset();
 22292   
 
 22293  21 
                 adaptor.addChild(root_0, root_1);
 22294   
                 }
 22295   
 
 22296  21 
             }
 22297  21 
 
 22298   
 
 22299  21 
             retval.tree = root_0;
 22300   
 
 22301   
             }
 22302  2 
 
 22303  21 
             retval.stop = input.LT(-1);
 22304  2 
 
 22305   
 
 22306  21 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22307  21 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22308   
 
 22309   
         }
 22310  0 
         catch (RecognitionException re) {
 22311  2 
             reportError(re);
 22312  2 
             recover(input,re);
 22313  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22314   
 
 22315  2 
         }
 22316   
 
 22317  2 
         finally {
 22318  2 
                 // do for sure before leaving
 22319  23 
         }
 22320  23 
         return retval;
 22321  2 
     }
 22322  2 
     // $ANTLR end "regexExpression"
 22323   
 
 22324  2 
 
 22325  2 
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22326  2 
         Object tree;
 22327  2 
         public Object getTree() { return tree; }
 22328   
     };
 22329  2 
 
 22330  2 
 
 22331  2 
     // $ANTLR start "subStringExpression"
 22332  2 
     // com\\googlecode\\sparkleg\\Sparql.g:600:1: subStringExpression : SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) ;
 22333  2 
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22334  4 
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22335  4 
         retval.start = input.LT(1);
 22336  2 
 
 22337  2 
 
 22338  4 
         Object root_0 = null;
 22339   
 
 22340  2 
         Token SUBSTR611=null;
 22341  2 
         Token OPEN_BRACE612=null;
 22342  2 
         Token COMMA614=null;
 22343  4 
         Token COMMA616=null;
 22344  4 
         Token CLOSE_BRACE618=null;
 22345  2 
         SparqlParser.expression_return expression613 =null;
 22346   
 
 22347  4 
         SparqlParser.expression_return expression615 =null;
 22348  2 
 
 22349  2 
         SparqlParser.expression_return expression617 =null;
 22350   
 
 22351  2 
 
 22352  4 
         Object SUBSTR611_tree=null;
 22353  2 
         Object OPEN_BRACE612_tree=null;
 22354  4 
         Object COMMA614_tree=null;
 22355  2 
         Object COMMA616_tree=null;
 22356  4 
         Object CLOSE_BRACE618_tree=null;
 22357  2 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22358  4 
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22359  4 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22360  2 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22361  2 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22362  2 
         try {
 22363  2 
             // com\\googlecode\\sparkleg\\Sparql.g:601:5: ( SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) )
 22364   
             // com\\googlecode\\sparkleg\\Sparql.g:601:7: SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22365  2 
             {
 22366  2 
             SUBSTR611=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6269);
 22367  4 
             stream_SUBSTR.add(SUBSTR611);
 22368   
 
 22369   
 
 22370  4 
             OPEN_BRACE612=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_subStringExpression6271);
 22371  4 
             stream_OPEN_BRACE.add(OPEN_BRACE612);
 22372   
 
 22373   
 
 22374  3 
             pushFollow(FOLLOW_expression_in_subStringExpression6273);
 22375  2 
             expression613=expression();
 22376   
 
 22377  2 
             state._fsp--;
 22378   
 
 22379  4 
             stream_expression.add(expression613.getTree());
 22380   
 
 22381  2 
             COMMA614=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6275);
 22382  2 
             stream_COMMA.add(COMMA614);
 22383  1 
 
 22384  1 
 
 22385  2 
             pushFollow(FOLLOW_expression_in_subStringExpression6277);
 22386  2 
             expression615=expression();
 22387  1 
 
 22388  3 
             state._fsp--;
 22389   
 
 22390  3 
             stream_expression.add(expression615.getTree());
 22391   
 
 22392  1 
             // com\\googlecode\\sparkleg\\Sparql.g:601:53: ( COMMA expression )?
 22393  2 
             int alt128=2;
 22394  2 
             switch ( input.LA(1) ) {
 22395   
                 case COMMA:
 22396   
                     {
 22397  1 
                     alt128=1;
 22398   
                     }
 22399   
                     break;
 22400  2 
             }
 22401  2 
 
 22402  2 
             switch (alt128) {
 22403   
                 case 1 :
 22404   
                     // com\\googlecode\\sparkleg\\Sparql.g:601:54: COMMA expression
 22405   
                     {
 22406  1 
                     COMMA616=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6280);
 22407  1 
                     stream_COMMA.add(COMMA616);
 22408   
 
 22409   
 
 22410  1 
                     pushFollow(FOLLOW_expression_in_subStringExpression6282);
 22411  3 
                     expression617=expression();
 22412  2 
 
 22413  1 
                     state._fsp--;
 22414  2 
 
 22415  1 
                     stream_expression.add(expression617.getTree());
 22416   
 
 22417   
                     }
 22418   
                     break;
 22419  2 
 
 22420  2 
             }
 22421   
 
 22422   
 
 22423  2 
             CLOSE_BRACE618=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_subStringExpression6286);
 22424  2 
             stream_CLOSE_BRACE.add(CLOSE_BRACE618);
 22425  7 
 
 22426  5 
 
 22427   
             // AST REWRITE
 22428   
             // elements: expression, SUBSTR
 22429  2 
             // token labels:
 22430   
             // rule labels: retval
 22431  2 
             // token list labels:
 22432   
             // rule list labels:
 22433   
             // wildcard labels:
 22434  2 
             retval.tree = root_0;
 22435  2 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22436   
 
 22437  4 
             root_0 = (Object)adaptor.nil();
 22438   
             // 601:85: -> ^( SUBSTR ( expression )* )
 22439   
             {
 22440   
                 // com\\googlecode\\sparkleg\\Sparql.g:601:88: ^( SUBSTR ( expression )* )
 22441  2 
                 {
 22442  2 
                 Object root_1 = (Object)adaptor.nil();
 22443  2 
                 root_1 = (Object)adaptor.becomeRoot(
 22444  2 
                 stream_SUBSTR.nextNode()
 22445  2 
                 , root_1);
 22446   
 
 22447   
                 // com\\googlecode\\sparkleg\\Sparql.g:601:97: ( expression )*
 22448  7 
                 while ( stream_expression.hasNext() ) {
 22449  5 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22450   
 
 22451   
                 }
 22452  2 
                 stream_expression.reset();
 22453   
 
 22454  2 
                 adaptor.addChild(root_0, root_1);
 22455   
                 }
 22456   
 
 22457  2 
             }
 22458  2 
 
 22459   
 
 22460  2 
             retval.tree = root_0;
 22461   
 
 22462   
             }
 22463  10 
 
 22464  2 
             retval.stop = input.LT(-1);
 22465  10 
 
 22466   
 
 22467  2 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22468  2 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22469   
 
 22470   
         }
 22471  0 
         catch (RecognitionException re) {
 22472  10 
             reportError(re);
 22473  10 
             recover(input,re);
 22474  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22475   
 
 22476  10 
         }
 22477   
 
 22478  10 
         finally {
 22479  10 
                 // do for sure before leaving
 22480  2 
         }
 22481  2 
         return retval;
 22482  10 
     }
 22483  10 
     // $ANTLR end "subStringExpression"
 22484  10 
 
 22485   
 
 22486  10 
     public static class existsFunction_return extends ParserRuleReturnScope {
 22487   
         Object tree;
 22488  10 
         public Object getTree() { return tree; }
 22489  10 
     };
 22490  10 
 
 22491   
 
 22492   
     // $ANTLR start "existsFunction"
 22493  10 
     // com\\googlecode\\sparkleg\\Sparql.g:604:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22494  10 
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22495  10 
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22496  20 
         retval.start = input.LT(1);
 22497   
 
 22498  10 
 
 22499  10 
         Object root_0 = null;
 22500   
 
 22501  10 
         Token EXISTS619=null;
 22502  10 
         SparqlParser.groupGraphPattern_return groupGraphPattern620 =null;
 22503   
 
 22504   
 
 22505  10 
         Object EXISTS619_tree=null;
 22506  10 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22507  20 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22508  10 
         try {
 22509   
             // com\\googlecode\\sparkleg\\Sparql.g:605:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22510  10 
             // com\\googlecode\\sparkleg\\Sparql.g:605:7: EXISTS groupGraphPattern
 22511   
             {
 22512  10 
             EXISTS619=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6316);
 22513  10 
             stream_EXISTS.add(EXISTS619);
 22514   
 
 22515  10 
 
 22516  20 
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6318);
 22517  10 
             groupGraphPattern620=groupGraphPattern();
 22518   
 
 22519  10 
             state._fsp--;
 22520  10 
 
 22521  10 
             stream_groupGraphPattern.add(groupGraphPattern620.getTree());
 22522  10 
 
 22523   
             // AST REWRITE
 22524   
             // elements: EXISTS, groupGraphPattern
 22525   
             // token labels:
 22526   
             // rule labels: retval
 22527   
             // token list labels:
 22528  10 
             // rule list labels:
 22529   
             // wildcard labels:
 22530  10 
             retval.tree = root_0;
 22531  10 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22532  10 
 
 22533  10 
             root_0 = (Object)adaptor.nil();
 22534   
             // 605:32: -> ^( EXISTS groupGraphPattern )
 22535  10 
             {
 22536  10 
                 // com\\googlecode\\sparkleg\\Sparql.g:605:35: ^( EXISTS groupGraphPattern )
 22537   
                 {
 22538  10 
                 Object root_1 = (Object)adaptor.nil();
 22539  10 
                 root_1 = (Object)adaptor.becomeRoot(
 22540   
                 stream_EXISTS.nextNode()
 22541   
                 , root_1);
 22542   
 
 22543  10 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22544   
 
 22545  10 
                 adaptor.addChild(root_0, root_1);
 22546   
                 }
 22547   
 
 22548  10 
             }
 22549  10 
 
 22550   
 
 22551  10 
             retval.tree = root_0;
 22552   
 
 22553   
             }
 22554  23 
 
 22555  10 
             retval.stop = input.LT(-1);
 22556  23 
 
 22557   
 
 22558  10 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22559  10 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22560   
 
 22561   
         }
 22562  0 
         catch (RecognitionException re) {
 22563  23 
             reportError(re);
 22564  23 
             recover(input,re);
 22565  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22566   
 
 22567  23 
         }
 22568   
 
 22569  23 
         finally {
 22570  23 
                 // do for sure before leaving
 22571  33 
         }
 22572  10 
         return retval;
 22573   
     }
 22574  23 
     // $ANTLR end "existsFunction"
 22575  23 
 
 22576  23 
 
 22577  23 
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 22578  23 
         Object tree;
 22579  23 
         public Object getTree() { return tree; }
 22580   
     };
 22581   
 
 22582   
 
 22583  23 
     // $ANTLR start "notExistsFunction"
 22584  23 
     // com\\googlecode\\sparkleg\\Sparql.g:608:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 22585   
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 22586  23 
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 22587  46 
         retval.start = input.LT(1);
 22588  23 
 
 22589   
 
 22590  23 
         Object root_0 = null;
 22591  23 
 
 22592  46 
         Token NOT621=null;
 22593  23 
         Token EXISTS622=null;
 22594  46 
         SparqlParser.groupGraphPattern_return groupGraphPattern623 =null;
 22595   
 
 22596  23 
 
 22597  23 
         Object NOT621_tree=null;
 22598  23 
         Object EXISTS622_tree=null;
 22599  23 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 22600  23 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22601  23 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22602   
         try {
 22603   
             // com\\googlecode\\sparkleg\\Sparql.g:609:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 22604   
             // com\\googlecode\\sparkleg\\Sparql.g:609:7: NOT EXISTS groupGraphPattern
 22605  23 
             {
 22606  46 
             NOT621=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6343);
 22607  23 
             stream_NOT.add(NOT621);
 22608  23 
 
 22609   
 
 22610  23 
             EXISTS622=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6345);
 22611  23 
             stream_EXISTS.add(EXISTS622);
 22612   
 
 22613  23 
 
 22614  46 
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6347);
 22615  23 
             groupGraphPattern623=groupGraphPattern();
 22616   
 
 22617  23 
             state._fsp--;
 22618  23 
 
 22619  23 
             stream_groupGraphPattern.add(groupGraphPattern623.getTree());
 22620  23 
 
 22621   
             // AST REWRITE
 22622   
             // elements: groupGraphPattern
 22623   
             // token labels:
 22624   
             // rule labels: retval
 22625   
             // token list labels:
 22626  23 
             // rule list labels:
 22627   
             // wildcard labels:
 22628  23 
             retval.tree = root_0;
 22629  23 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22630  23 
 
 22631  23 
             root_0 = (Object)adaptor.nil();
 22632   
             // 609:36: -> ^( NOT_EXISTS groupGraphPattern )
 22633  23 
             {
 22634  23 
                 // com\\googlecode\\sparkleg\\Sparql.g:609:39: ^( NOT_EXISTS groupGraphPattern )
 22635   
                 {
 22636  23 
                 Object root_1 = (Object)adaptor.nil();
 22637  23 
                 root_1 = (Object)adaptor.becomeRoot(
 22638   
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 22639   
                 , root_1);
 22640   
 
 22641  23 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22642   
 
 22643  23 
                 adaptor.addChild(root_0, root_1);
 22644   
                 }
 22645   
 
 22646  23 
             }
 22647  23 
 
 22648   
 
 22649  23 
             retval.tree = root_0;
 22650   
 
 22651   
             }
 22652  53 
 
 22653  23 
             retval.stop = input.LT(-1);
 22654  53 
 
 22655   
 
 22656  23 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22657  23 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22658   
 
 22659   
         }
 22660  0 
         catch (RecognitionException re) {
 22661  53 
             reportError(re);
 22662  53 
             recover(input,re);
 22663  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22664   
 
 22665  53 
         }
 22666   
 
 22667  53 
         finally {
 22668  53 
                 // do for sure before leaving
 22669  76 
         }
 22670  76 
         return retval;
 22671  53 
     }
 22672  53 
     // $ANTLR end "notExistsFunction"
 22673  53 
 
 22674  53 
 
 22675  53 
     public static class aggregate_return extends ParserRuleReturnScope {
 22676  53 
         Object tree;
 22677  53 
         public Object getTree() { return tree; }
 22678  53 
     };
 22679  53 
 
 22680  53 
 
 22681  53 
     // $ANTLR start "aggregate"
 22682  53 
     // com\\googlecode\\sparkleg\\Sparql.g:612:1: aggregate : ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 22683  53 
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 22684  106 
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 22685  106 
         retval.start = input.LT(1);
 22686  53 
 
 22687  53 
 
 22688  106 
         Object root_0 = null;
 22689  53 
 
 22690  106 
         Token COUNT624=null;
 22691  106 
         Token OPEN_BRACE625=null;
 22692  106 
         Token DISTINCT626=null;
 22693  106 
         Token ASTERISK627=null;
 22694  106 
         Token CLOSE_BRACE629=null;
 22695  106 
         Token SUM630=null;
 22696  106 
         Token OPEN_BRACE631=null;
 22697  106 
         Token DISTINCT632=null;
 22698  106 
         Token CLOSE_BRACE634=null;
 22699  106 
         Token MIN635=null;
 22700  53 
         Token OPEN_BRACE636=null;
 22701  106 
         Token DISTINCT637=null;
 22702  53 
         Token CLOSE_BRACE639=null;
 22703  106 
         Token MAX640=null;
 22704  53 
         Token OPEN_BRACE641=null;
 22705  106 
         Token DISTINCT642=null;
 22706  53 
         Token CLOSE_BRACE644=null;
 22707  106 
         Token AVG645=null;
 22708  53 
         Token OPEN_BRACE646=null;
 22709  106 
         Token DISTINCT647=null;
 22710  53 
         Token CLOSE_BRACE649=null;
 22711  106 
         Token SAMPLE650=null;
 22712  53 
         Token OPEN_BRACE651=null;
 22713  106 
         Token DISTINCT652=null;
 22714  53 
         Token CLOSE_BRACE654=null;
 22715  53 
         Token GROUP_CONCAT655=null;
 22716  106 
         Token OPEN_BRACE656=null;
 22717  106 
         Token DISTINCT657=null;
 22718  106 
         Token SEMICOLON659=null;
 22719  106 
         Token SEPARATOR660=null;
 22720  106 
         Token EQUAL661=null;
 22721  106 
         Token CLOSE_BRACE663=null;
 22722  106 
         SparqlParser.expression_return expression628 =null;
 22723  53 
 
 22724  106 
         SparqlParser.expression_return expression633 =null;
 22725  53 
 
 22726  106 
         SparqlParser.expression_return expression638 =null;
 22727  53 
 
 22728  106 
         SparqlParser.expression_return expression643 =null;
 22729  53 
 
 22730  106 
         SparqlParser.expression_return expression648 =null;
 22731  53 
 
 22732  106 
         SparqlParser.expression_return expression653 =null;
 22733  53 
 
 22734  106 
         SparqlParser.expression_return expression658 =null;
 22735  53 
 
 22736  106 
         SparqlParser.string_return string662 =null;
 22737  53 
 
 22738  53 
 
 22739  106 
         Object COUNT624_tree=null;
 22740  106 
         Object OPEN_BRACE625_tree=null;
 22741  106 
         Object DISTINCT626_tree=null;
 22742  106 
         Object ASTERISK627_tree=null;
 22743  106 
         Object CLOSE_BRACE629_tree=null;
 22744  106 
         Object SUM630_tree=null;
 22745  106 
         Object OPEN_BRACE631_tree=null;
 22746  106 
         Object DISTINCT632_tree=null;
 22747  106 
         Object CLOSE_BRACE634_tree=null;
 22748  106 
         Object MIN635_tree=null;
 22749  106 
         Object OPEN_BRACE636_tree=null;
 22750  106 
         Object DISTINCT637_tree=null;
 22751  106 
         Object CLOSE_BRACE639_tree=null;
 22752  106 
         Object MAX640_tree=null;
 22753  106 
         Object OPEN_BRACE641_tree=null;
 22754  106 
         Object DISTINCT642_tree=null;
 22755  106 
         Object CLOSE_BRACE644_tree=null;
 22756  106 
         Object AVG645_tree=null;
 22757  106 
         Object OPEN_BRACE646_tree=null;
 22758  106 
         Object DISTINCT647_tree=null;
 22759  106 
         Object CLOSE_BRACE649_tree=null;
 22760  106 
         Object SAMPLE650_tree=null;
 22761  106 
         Object OPEN_BRACE651_tree=null;
 22762  106 
         Object DISTINCT652_tree=null;
 22763  106 
         Object CLOSE_BRACE654_tree=null;
 22764  53 
         Object GROUP_CONCAT655_tree=null;
 22765  53 
         Object OPEN_BRACE656_tree=null;
 22766  106 
         Object DISTINCT657_tree=null;
 22767  106 
         Object SEMICOLON659_tree=null;
 22768  53 
         Object SEPARATOR660_tree=null;
 22769  53 
         Object EQUAL661_tree=null;
 22770  70 
         Object CLOSE_BRACE663_tree=null;
 22771  53 
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 22772  70 
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 22773  53 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 22774  53 
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 22775  59 
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 22776  53 
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 22777  59 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 22778  53 
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 22779  53 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22780  60 
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 22781  53 
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 22782  60 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 22783  53 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22784  53 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 22785  58 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22786  53 
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 22787  5 
         try {
 22788   
             // com\\googlecode\\sparkleg\\Sparql.g:613:5: ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 22789  53 
             int alt138=7;
 22790  65 
             switch ( input.LA(1) ) {
 22791   
             case COUNT:
 22792  12 
                 {
 22793  17 
                 alt138=1;
 22794   
                 }
 22795  20 
                 break;
 22796   
             case SUM:
 22797  3 
                 {
 22798  6 
                 alt138=2;
 22799   
                 }
 22800  9 
                 break;
 22801   
             case MIN:
 22802  3 
                 {
 22803  7 
                 alt138=3;
 22804   
                 }
 22805  7 
                 break;
 22806   
             case MAX:
 22807   
                 {
 22808  5 
                 alt138=4;
 22809   
                 }
 22810  5 
                 break;
 22811  53 
             case AVG:
 22812   
                 {
 22813  12 
                 alt138=5;
 22814   
                 }
 22815  29 
                 break;
 22816  17 
             case SAMPLE:
 22817   
                 {
 22818  3 
                 alt138=6;
 22819  17 
                 }
 22820  20 
                 break;
 22821   
             case GROUP_CONCAT:
 22822   
                 {
 22823  3 
                 alt138=7;
 22824  17 
                 }
 22825  20 
                 break;
 22826   
             default:
 22827  0 
                 NoViableAltException nvae =
 22828   
                     new NoViableAltException("", 138, 0, input);
 22829   
 
 22830  0 
                 throw nvae;
 22831   
 
 22832   
             }
 22833  17 
 
 22834  53 
             switch (alt138) {
 22835   
                 case 1 :
 22836   
                     // com\\googlecode\\sparkleg\\Sparql.g:613:7: COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE
 22837   
                     {
 22838  17 
                     COUNT624=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6372);
 22839  17 
                     stream_COUNT.add(COUNT624);
 22840   
 
 22841   
 
 22842  17 
                     OPEN_BRACE625=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6374);
 22843  17 
                     stream_OPEN_BRACE.add(OPEN_BRACE625);
 22844   
 
 22845   
 
 22846   
                     // com\\googlecode\\sparkleg\\Sparql.g:613:24: ( DISTINCT )?
 22847  17 
                     int alt129=2;
 22848  34 
                     switch ( input.LA(1) ) {
 22849  17 
                         case DISTINCT:
 22850   
                             {
 22851  0 
                             alt129=1;
 22852  7 
                             }
 22853   
                             break;
 22854  7 
                     }
 22855   
 
 22856  17 
                     switch (alt129) {
 22857   
                         case 1 :
 22858   
                             // com\\googlecode\\sparkleg\\Sparql.g:613:24: DISTINCT
 22859   
                             {
 22860  0 
                             DISTINCT626=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6376);
 22861  0 
                             stream_DISTINCT.add(DISTINCT626);
 22862   
 
 22863   
 
 22864   
                             }
 22865   
                             break;
 22866   
 
 22867   
                     }
 22868   
 
 22869   
 
 22870   
                     // com\\googlecode\\sparkleg\\Sparql.g:613:34: ( ASTERISK | expression )
 22871  17 
                     int alt130=2;
 22872  17 
                     switch ( input.LA(1) ) {
 22873   
                     case ASTERISK:
 22874   
                         {
 22875  7 
                         alt130=1;
 22876   
                         }
 22877  7 
                         break;
 22878   
                     case ABS:
 22879   
                     case AVG:
 22880   
                     case BNODE:
 22881   
                     case BOUND:
 22882   
                     case CEIL:
 22883   
                     case COALESCE:
 22884   
                     case CONCAT:
 22885   
                     case CONTAINS:
 22886   
                     case COUNT:
 22887   
                     case DATATYPE:
 22888   
                     case DAY:
 22889   
                     case DECIMAL:
 22890   
                     case DECIMAL_NEGATIVE:
 22891   
                     case DECIMAL_POSITIVE:
 22892   
                     case DOUBLE:
 22893   
                     case DOUBLE_NEGATIVE:
 22894   
                     case DOUBLE_POSITIVE:
 22895   
                     case ENCODE_FOR_URI:
 22896   
                     case EXISTS:
 22897   
                     case FALSE:
 22898   
                     case FLOOR:
 22899   
                     case GROUP_CONCAT:
 22900   
                     case HOURS:
 22901   
                     case IF:
 22902   
                     case INTEGER:
 22903   
                     case INTEGER_NEGATIVE:
 22904   
                     case INTEGER_POSITIVE:
 22905   
                     case IRI:
 22906   
                     case IRI_REF:
 22907   
                     case ISBLANK:
 22908   
                     case ISIRI:
 22909   
                     case ISLITERAL:
 22910   
                     case ISNUMERIC:
 22911   
                     case ISURI:
 22912   
                     case LANG:
 22913   
                     case LANGMATCHES:
 22914   
                     case LCASE:
 22915   
                     case MAX:
 22916   
                     case MD5:
 22917   
                     case MIN:
 22918   
                     case MINUS:
 22919   
                     case MINUTES:
 22920   
                     case MONTH:
 22921   
                     case NEGATION:
 22922   
                     case NOT:
 22923   
                     case NOW:
 22924   
                     case OPEN_BRACE:
 22925   
                     case PLUS:
 22926   
                     case PNAME_LN:
 22927   
                     case PNAME_NS:
 22928   
                     case RAND:
 22929   
                     case REGEX:
 22930   
                     case REPLACE:
 22931   
                     case ROUND:
 22932   
                     case SAMETERM:
 22933   
                     case SAMPLE:
 22934   
                     case SECONDS:
 22935   
                     case SHA1:
 22936   
                     case SHA224:
 22937   
                     case SHA256:
 22938   
                     case SHA384:
 22939   
                     case SHA512:
 22940  10 
                     case STR:
 22941   
                     case STRAFTER:
 22942  10 
                     case STRBEFORE:
 22943   
                     case STRDT:
 22944   
                     case STRENDS:
 22945   
                     case STRING_LITERAL1:
 22946   
                     case STRING_LITERAL2:
 22947   
                     case STRING_LITERAL_LONG1:
 22948   
                     case STRING_LITERAL_LONG2:
 22949   
                     case STRLANG:
 22950   
                     case STRLEN:
 22951  17 
                     case STRSTARTS:
 22952   
                     case SUBSTR:
 22953   
                     case SUM:
 22954   
                     case TIMEZONE:
 22955  7 
                     case TRUE:
 22956  7 
                     case TZ:
 22957   
                     case UCASE:
 22958   
                     case URI:
 22959   
                     case VAR1:
 22960  7 
                     case VAR2:
 22961   
                     case YEAR:
 22962   
                         {
 22963  10 
                         alt130=2;
 22964  10 
                         }
 22965  20 
                         break;
 22966   
                     default:
 22967  10 
                         NoViableAltException nvae =
 22968   
                             new NoViableAltException("", 130, 0, input);
 22969  10 
 
 22970  0 
                         throw nvae;
 22971   
 
 22972   
                     }
 22973   
 
 22974  17 
                     switch (alt130) {
 22975   
                         case 1 :
 22976   
                             // com\\googlecode\\sparkleg\\Sparql.g:613:35: ASTERISK
 22977  17 
                             {
 22978  24 
                             ASTERISK627=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6380);
 22979  7 
                             stream_ASTERISK.add(ASTERISK627);
 22980   
 
 22981   
 
 22982   
                             }
 22983  7 
                             break;
 22984   
                         case 2 :
 22985   
                             // com\\googlecode\\sparkleg\\Sparql.g:613:46: expression
 22986   
                             {
 22987  10 
                             pushFollow(FOLLOW_expression_in_aggregate6384);
 22988  27 
                             expression628=expression();
 22989  17 
 
 22990  10 
                             state._fsp--;
 22991  17 
 
 22992  10 
                             stream_expression.add(expression628.getTree());
 22993   
 
 22994   
                             }
 22995   
                             break;
 22996  17 
 
 22997  17 
                     }
 22998   
 
 22999   
 
 23000  17 
                     CLOSE_BRACE629=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6387);
 23001  17 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE629);
 23002  17 
 
 23003   
 
 23004   
                     // AST REWRITE
 23005   
                     // elements: DISTINCT, COUNT, expression, ASTERISK
 23006   
                     // token labels:
 23007   
                     // rule labels: retval
 23008  17 
                     // token list labels:
 23009   
                     // rule list labels:
 23010   
                     // wildcard labels:
 23011  41 
                     retval.tree = root_0;
 23012  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23013   
 
 23014  17 
                     root_0 = (Object)adaptor.nil();
 23015   
                     // 613:70: -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23016   
                     {
 23017  17 
                         // com\\googlecode\\sparkleg\\Sparql.g:613:73: ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23018   
                         {
 23019  17 
                         Object root_1 = (Object)adaptor.nil();
 23020  44 
                         root_1 = (Object)adaptor.becomeRoot(
 23021  10 
                         stream_COUNT.nextNode()
 23022   
                         , root_1);
 23023   
 
 23024  17 
                         // com\\googlecode\\sparkleg\\Sparql.g:613:81: ( DISTINCT )*
 23025  17 
                         while ( stream_DISTINCT.hasNext() ) {
 23026  17 
                             adaptor.addChild(root_1,
 23027   
                             stream_DISTINCT.nextNode()
 23028   
                             );
 23029   
 
 23030   
                         }
 23031  17 
                         stream_DISTINCT.reset();
 23032  17 
 
 23033   
                         // com\\googlecode\\sparkleg\\Sparql.g:613:91: ( ASTERISK )*
 23034  24 
                         while ( stream_ASTERISK.hasNext() ) {
 23035  24 
                             adaptor.addChild(root_1,
 23036   
                             stream_ASTERISK.nextNode()
 23037   
                             );
 23038   
 
 23039  6 
                         }
 23040  23 
                         stream_ASTERISK.reset();
 23041   
 
 23042   
                         // com\\googlecode\\sparkleg\\Sparql.g:613:101: ( expression )*
 23043  33 
                         while ( stream_expression.hasNext() ) {
 23044  16 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23045   
 
 23046   
                         }
 23047  17 
                         stream_expression.reset();
 23048  6 
 
 23049  23 
                         adaptor.addChild(root_0, root_1);
 23050   
                         }
 23051   
 
 23052   
                     }
 23053   
 
 23054   
 
 23055  17 
                     retval.tree = root_0;
 23056   
 
 23057  6 
                     }
 23058  17 
                     break;
 23059   
                 case 2 :
 23060   
                     // com\\googlecode\\sparkleg\\Sparql.g:614:7: SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23061   
                     {
 23062  6 
                     SUM630=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6410);
 23063  6 
                     stream_SUM.add(SUM630);
 23064   
 
 23065   
 
 23066  6 
                     OPEN_BRACE631=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6412);
 23067  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE631);
 23068   
 
 23069   
 
 23070   
                     // com\\googlecode\\sparkleg\\Sparql.g:614:22: ( DISTINCT )?
 23071  12 
                     int alt131=2;
 23072  12 
                     switch ( input.LA(1) ) {
 23073   
                         case DISTINCT:
 23074  6 
                             {
 23075  0 
                             alt131=1;
 23076  6 
                             }
 23077   
                             break;
 23078  6 
                     }
 23079  6 
 
 23080  6 
                     switch (alt131) {
 23081   
                         case 1 :
 23082   
                             // com\\googlecode\\sparkleg\\Sparql.g:614:22: DISTINCT
 23083   
                             {
 23084  0 
                             DISTINCT632=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6414);
 23085  0 
                             stream_DISTINCT.add(DISTINCT632);
 23086   
 
 23087   
 
 23088   
                             }
 23089  6 
                             break;
 23090  6 
 
 23091   
                     }
 23092  6 
 
 23093   
 
 23094  6 
                     pushFollow(FOLLOW_expression_in_aggregate6417);
 23095  6 
                     expression633=expression();
 23096   
 
 23097  12 
                     state._fsp--;
 23098  6 
 
 23099  6 
                     stream_expression.add(expression633.getTree());
 23100   
 
 23101  6 
                     CLOSE_BRACE634=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6419);
 23102  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE634);
 23103  6 
 
 23104   
 
 23105   
                     // AST REWRITE
 23106   
                     // elements: expression, DISTINCT, SUM
 23107   
                     // token labels:
 23108   
                     // rule labels: retval
 23109  6 
                     // token list labels:
 23110   
                     // rule list labels:
 23111  6 
                     // wildcard labels:
 23112  6 
                     retval.tree = root_0;
 23113  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23114   
 
 23115  6 
                     root_0 = (Object)adaptor.nil();
 23116   
                     // 614:55: -> ^( SUM ( DISTINCT )* expression )
 23117   
                     {
 23118   
                         // com\\googlecode\\sparkleg\\Sparql.g:614:58: ^( SUM ( DISTINCT )* expression )
 23119  6 
                         {
 23120  6 
                         Object root_1 = (Object)adaptor.nil();
 23121  6 
                         root_1 = (Object)adaptor.becomeRoot(
 23122  6 
                         stream_SUM.nextNode()
 23123   
                         , root_1);
 23124   
 
 23125   
                         // com\\googlecode\\sparkleg\\Sparql.g:614:64: ( DISTINCT )*
 23126  13 
                         while ( stream_DISTINCT.hasNext() ) {
 23127  7 
                             adaptor.addChild(root_1,
 23128   
                             stream_DISTINCT.nextNode()
 23129   
                             );
 23130  7 
 
 23131  7 
                         }
 23132  6 
                         stream_DISTINCT.reset();
 23133   
 
 23134  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23135  7 
 
 23136  13 
                         adaptor.addChild(root_0, root_1);
 23137   
                         }
 23138   
 
 23139   
                     }
 23140   
 
 23141   
 
 23142  6 
                     retval.tree = root_0;
 23143   
 
 23144  7 
                     }
 23145  6 
                     break;
 23146   
                 case 3 :
 23147   
                     // com\\googlecode\\sparkleg\\Sparql.g:615:7: MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23148   
                     {
 23149  7 
                     MIN635=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6438);
 23150  7 
                     stream_MIN.add(MIN635);
 23151   
 
 23152   
 
 23153  7 
                     OPEN_BRACE636=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6440);
 23154  7 
                     stream_OPEN_BRACE.add(OPEN_BRACE636);
 23155   
 
 23156   
 
 23157   
                     // com\\googlecode\\sparkleg\\Sparql.g:615:22: ( DISTINCT )?
 23158  14 
                     int alt132=2;
 23159  14 
                     switch ( input.LA(1) ) {
 23160   
                         case DISTINCT:
 23161  7 
                             {
 23162  0 
                             alt132=1;
 23163  7 
                             }
 23164   
                             break;
 23165  7 
                     }
 23166  7 
 
 23167  7 
                     switch (alt132) {
 23168   
                         case 1 :
 23169   
                             // com\\googlecode\\sparkleg\\Sparql.g:615:22: DISTINCT
 23170   
                             {
 23171  0 
                             DISTINCT637=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6442);
 23172  0 
                             stream_DISTINCT.add(DISTINCT637);
 23173   
 
 23174   
 
 23175   
                             }
 23176  7 
                             break;
 23177  7 
 
 23178   
                     }
 23179  7 
 
 23180   
 
 23181  7 
                     pushFollow(FOLLOW_expression_in_aggregate6445);
 23182  7 
                     expression638=expression();
 23183   
 
 23184  14 
                     state._fsp--;
 23185  7 
 
 23186  7 
                     stream_expression.add(expression638.getTree());
 23187   
 
 23188  7 
                     CLOSE_BRACE639=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6447);
 23189  7 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE639);
 23190  7 
 
 23191   
 
 23192   
                     // AST REWRITE
 23193   
                     // elements: DISTINCT, MIN, expression
 23194   
                     // token labels:
 23195   
                     // rule labels: retval
 23196  7 
                     // token list labels:
 23197   
                     // rule list labels:
 23198  7 
                     // wildcard labels:
 23199  7 
                     retval.tree = root_0;
 23200  14 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23201   
 
 23202  7 
                     root_0 = (Object)adaptor.nil();
 23203   
                     // 615:55: -> ^( MIN ( DISTINCT )* expression )
 23204   
                     {
 23205   
                         // com\\googlecode\\sparkleg\\Sparql.g:615:58: ^( MIN ( DISTINCT )* expression )
 23206  7 
                         {
 23207  7 
                         Object root_1 = (Object)adaptor.nil();
 23208  7 
                         root_1 = (Object)adaptor.becomeRoot(
 23209  7 
                         stream_MIN.nextNode()
 23210   
                         , root_1);
 23211   
 
 23212   
                         // com\\googlecode\\sparkleg\\Sparql.g:615:64: ( DISTINCT )*
 23213  12 
                         while ( stream_DISTINCT.hasNext() ) {
 23214  5 
                             adaptor.addChild(root_1,
 23215   
                             stream_DISTINCT.nextNode()
 23216   
                             );
 23217  5 
 
 23218  5 
                         }
 23219  7 
                         stream_DISTINCT.reset();
 23220   
 
 23221  7 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23222  5 
 
 23223  12 
                         adaptor.addChild(root_0, root_1);
 23224   
                         }
 23225   
 
 23226   
                     }
 23227   
 
 23228   
 
 23229  7 
                     retval.tree = root_0;
 23230   
 
 23231  5 
                     }
 23232  7 
                     break;
 23233   
                 case 4 :
 23234   
                     // com\\googlecode\\sparkleg\\Sparql.g:616:7: MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23235   
                     {
 23236  5 
                     MAX640=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6466);
 23237  5 
                     stream_MAX.add(MAX640);
 23238   
 
 23239   
 
 23240  5 
                     OPEN_BRACE641=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6468);
 23241  5 
                     stream_OPEN_BRACE.add(OPEN_BRACE641);
 23242   
 
 23243   
 
 23244   
                     // com\\googlecode\\sparkleg\\Sparql.g:616:22: ( DISTINCT )?
 23245  10 
                     int alt133=2;
 23246  10 
                     switch ( input.LA(1) ) {
 23247   
                         case DISTINCT:
 23248  5 
                             {
 23249  0 
                             alt133=1;
 23250  5 
                             }
 23251   
                             break;
 23252  5 
                     }
 23253  5 
 
 23254  5 
                     switch (alt133) {
 23255   
                         case 1 :
 23256   
                             // com\\googlecode\\sparkleg\\Sparql.g:616:22: DISTINCT
 23257   
                             {
 23258  0 
                             DISTINCT642=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6470);
 23259  0 
                             stream_DISTINCT.add(DISTINCT642);
 23260   
 
 23261   
 
 23262   
                             }
 23263  5 
                             break;
 23264  5 
 
 23265   
                     }
 23266  5 
 
 23267   
 
 23268  5 
                     pushFollow(FOLLOW_expression_in_aggregate6473);
 23269  5 
                     expression643=expression();
 23270   
 
 23271  10 
                     state._fsp--;
 23272  5 
 
 23273  5 
                     stream_expression.add(expression643.getTree());
 23274   
 
 23275  5 
                     CLOSE_BRACE644=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6475);
 23276  5 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE644);
 23277  5 
 
 23278   
 
 23279   
                     // AST REWRITE
 23280   
                     // elements: expression, DISTINCT, MAX
 23281   
                     // token labels:
 23282   
                     // rule labels: retval
 23283  5 
                     // token list labels:
 23284   
                     // rule list labels:
 23285  5 
                     // wildcard labels:
 23286  5 
                     retval.tree = root_0;
 23287  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23288   
 
 23289  5 
                     root_0 = (Object)adaptor.nil();
 23290   
                     // 616:55: -> ^( MAX ( DISTINCT )* expression )
 23291   
                     {
 23292   
                         // com\\googlecode\\sparkleg\\Sparql.g:616:58: ^( MAX ( DISTINCT )* expression )
 23293  5 
                         {
 23294  5 
                         Object root_1 = (Object)adaptor.nil();
 23295  5 
                         root_1 = (Object)adaptor.becomeRoot(
 23296  5 
                         stream_MAX.nextNode()
 23297   
                         , root_1);
 23298   
 
 23299   
                         // com\\googlecode\\sparkleg\\Sparql.g:616:64: ( DISTINCT )*
 23300  17 
                         while ( stream_DISTINCT.hasNext() ) {
 23301  12 
                             adaptor.addChild(root_1,
 23302   
                             stream_DISTINCT.nextNode()
 23303   
                             );
 23304  12 
 
 23305  12 
                         }
 23306  5 
                         stream_DISTINCT.reset();
 23307   
 
 23308  5 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23309  12 
 
 23310  17 
                         adaptor.addChild(root_0, root_1);
 23311   
                         }
 23312   
 
 23313   
                     }
 23314   
 
 23315   
 
 23316  5 
                     retval.tree = root_0;
 23317   
 
 23318  12 
                     }
 23319  5 
                     break;
 23320   
                 case 5 :
 23321   
                     // com\\googlecode\\sparkleg\\Sparql.g:617:7: AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23322   
                     {
 23323  12 
                     AVG645=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6494);
 23324  12 
                     stream_AVG.add(AVG645);
 23325   
 
 23326   
 
 23327  12 
                     OPEN_BRACE646=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6496);
 23328  12 
                     stream_OPEN_BRACE.add(OPEN_BRACE646);
 23329   
 
 23330   
 
 23331   
                     // com\\googlecode\\sparkleg\\Sparql.g:617:22: ( DISTINCT )?
 23332  24 
                     int alt134=2;
 23333  24 
                     switch ( input.LA(1) ) {
 23334   
                         case DISTINCT:
 23335  12 
                             {
 23336  0 
                             alt134=1;
 23337  12 
                             }
 23338   
                             break;
 23339  12 
                     }
 23340  12 
 
 23341  12 
                     switch (alt134) {
 23342   
                         case 1 :
 23343   
                             // com\\googlecode\\sparkleg\\Sparql.g:617:22: DISTINCT
 23344   
                             {
 23345  0 
                             DISTINCT647=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6498);
 23346  0 
                             stream_DISTINCT.add(DISTINCT647);
 23347   
 
 23348   
 
 23349   
                             }
 23350  12 
                             break;
 23351  12 
 
 23352   
                     }
 23353  12 
 
 23354   
 
 23355  12 
                     pushFollow(FOLLOW_expression_in_aggregate6501);
 23356  12 
                     expression648=expression();
 23357   
 
 23358  24 
                     state._fsp--;
 23359  12 
 
 23360  12 
                     stream_expression.add(expression648.getTree());
 23361   
 
 23362  12 
                     CLOSE_BRACE649=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6503);
 23363  12 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE649);
 23364  12 
 
 23365   
 
 23366   
                     // AST REWRITE
 23367   
                     // elements: AVG, expression, DISTINCT
 23368   
                     // token labels:
 23369   
                     // rule labels: retval
 23370  12 
                     // token list labels:
 23371   
                     // rule list labels:
 23372  12 
                     // wildcard labels:
 23373  12 
                     retval.tree = root_0;
 23374  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23375   
 
 23376  12 
                     root_0 = (Object)adaptor.nil();
 23377   
                     // 617:55: -> ^( AVG ( DISTINCT )* expression )
 23378   
                     {
 23379   
                         // com\\googlecode\\sparkleg\\Sparql.g:617:58: ^( AVG ( DISTINCT )* expression )
 23380  12 
                         {
 23381  12 
                         Object root_1 = (Object)adaptor.nil();
 23382  12 
                         root_1 = (Object)adaptor.becomeRoot(
 23383  12 
                         stream_AVG.nextNode()
 23384   
                         , root_1);
 23385   
 
 23386   
                         // com\\googlecode\\sparkleg\\Sparql.g:617:64: ( DISTINCT )*
 23387  15 
                         while ( stream_DISTINCT.hasNext() ) {
 23388  3 
                             adaptor.addChild(root_1,
 23389   
                             stream_DISTINCT.nextNode()
 23390   
                             );
 23391  3 
 
 23392  3 
                         }
 23393  12 
                         stream_DISTINCT.reset();
 23394   
 
 23395  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23396  3 
 
 23397  15 
                         adaptor.addChild(root_0, root_1);
 23398   
                         }
 23399   
 
 23400   
                     }
 23401   
 
 23402   
 
 23403  12 
                     retval.tree = root_0;
 23404   
 
 23405  3 
                     }
 23406  12 
                     break;
 23407   
                 case 6 :
 23408   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23409   
                     {
 23410  3 
                     SAMPLE650=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6522);
 23411  3 
                     stream_SAMPLE.add(SAMPLE650);
 23412   
 
 23413   
 
 23414  3 
                     OPEN_BRACE651=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6524);
 23415  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE651);
 23416   
 
 23417   
 
 23418   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:25: ( DISTINCT )?
 23419  6 
                     int alt135=2;
 23420  6 
                     switch ( input.LA(1) ) {
 23421   
                         case DISTINCT:
 23422  3 
                             {
 23423  0 
                             alt135=1;
 23424  3 
                             }
 23425   
                             break;
 23426  3 
                     }
 23427  3 
 
 23428  3 
                     switch (alt135) {
 23429   
                         case 1 :
 23430   
                             // com\\googlecode\\sparkleg\\Sparql.g:618:25: DISTINCT
 23431   
                             {
 23432  0 
                             DISTINCT652=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6526);
 23433  0 
                             stream_DISTINCT.add(DISTINCT652);
 23434   
 
 23435   
 
 23436   
                             }
 23437  3 
                             break;
 23438  3 
 
 23439   
                     }
 23440  3 
 
 23441   
 
 23442  3 
                     pushFollow(FOLLOW_expression_in_aggregate6529);
 23443  3 
                     expression653=expression();
 23444   
 
 23445  6 
                     state._fsp--;
 23446  3 
 
 23447  3 
                     stream_expression.add(expression653.getTree());
 23448   
 
 23449  3 
                     CLOSE_BRACE654=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6531);
 23450  3 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE654);
 23451  3 
 
 23452   
 
 23453   
                     // AST REWRITE
 23454   
                     // elements: DISTINCT, expression, SAMPLE
 23455   
                     // token labels:
 23456   
                     // rule labels: retval
 23457  3 
                     // token list labels:
 23458   
                     // rule list labels:
 23459  3 
                     // wildcard labels:
 23460  3 
                     retval.tree = root_0;
 23461  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23462   
 
 23463  3 
                     root_0 = (Object)adaptor.nil();
 23464   
                     // 618:58: -> ^( SAMPLE ( DISTINCT )? expression )
 23465   
                     {
 23466   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:61: ^( SAMPLE ( DISTINCT )? expression )
 23467  3 
                         {
 23468  3 
                         Object root_1 = (Object)adaptor.nil();
 23469  3 
                         root_1 = (Object)adaptor.becomeRoot(
 23470  3 
                         stream_SAMPLE.nextNode()
 23471   
                         , root_1);
 23472   
 
 23473   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:70: ( DISTINCT )?
 23474  6 
                         if ( stream_DISTINCT.hasNext() ) {
 23475  3 
                             adaptor.addChild(root_1,
 23476   
                             stream_DISTINCT.nextNode()
 23477   
                             );
 23478  3 
 
 23479  3 
                         }
 23480  3 
                         stream_DISTINCT.reset();
 23481   
 
 23482  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23483  3 
 
 23484  6 
                         adaptor.addChild(root_0, root_1);
 23485   
                         }
 23486   
 
 23487   
                     }
 23488   
 
 23489   
 
 23490  3 
                     retval.tree = root_0;
 23491   
 
 23492  3 
                     }
 23493  3 
                     break;
 23494   
                 case 7 :
 23495   
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE
 23496   
                     {
 23497  3 
                     GROUP_CONCAT655=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6550);
 23498  3 
                     stream_GROUP_CONCAT.add(GROUP_CONCAT655);
 23499   
 
 23500   
 
 23501  3 
                     OPEN_BRACE656=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6552);
 23502  3 
                     stream_OPEN_BRACE.add(OPEN_BRACE656);
 23503   
 
 23504   
 
 23505   
                     // com\\googlecode\\sparkleg\\Sparql.g:619:31: ( DISTINCT )?
 23506  6 
                     int alt136=2;
 23507  6 
                     switch ( input.LA(1) ) {
 23508   
                         case DISTINCT:
 23509  3 
                             {
 23510  0 
                             alt136=1;
 23511  3 
                             }
 23512   
                             break;
 23513   
                     }
 23514  3 
 
 23515  6 
                     switch (alt136) {
 23516   
                         case 1 :
 23517   
                             // com\\googlecode\\sparkleg\\Sparql.g:619:31: DISTINCT
 23518  1 
                             {
 23519  0 
                             DISTINCT657=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6554);
 23520  0 
                             stream_DISTINCT.add(DISTINCT657);
 23521   
 
 23522   
 
 23523  3 
                             }
 23524   
                             break;
 23525   
 
 23526   
                     }
 23527  1 
 
 23528  1 
 
 23529  3 
                     pushFollow(FOLLOW_expression_in_aggregate6557);
 23530  3 
                     expression658=expression();
 23531  1 
 
 23532  4 
                     state._fsp--;
 23533   
 
 23534  3 
                     stream_expression.add(expression658.getTree());
 23535  1 
 
 23536  1 
                     // com\\googlecode\\sparkleg\\Sparql.g:619:52: ( SEMICOLON SEPARATOR EQUAL string )?
 23537  3 
                     int alt137=2;
 23538  3 
                     switch ( input.LA(1) ) {
 23539  1 
                         case SEMICOLON:
 23540  1 
                             {
 23541  1 
                             alt137=1;
 23542  1 
                             }
 23543   
                             break;
 23544  1 
                     }
 23545   
 
 23546  3 
                     switch (alt137) {
 23547   
                         case 1 :
 23548   
                             // com\\googlecode\\sparkleg\\Sparql.g:619:53: SEMICOLON SEPARATOR EQUAL string
 23549   
                             {
 23550  1 
                             SEMICOLON659=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_aggregate6560);
 23551  1 
                             stream_SEMICOLON.add(SEMICOLON659);
 23552  3 
 
 23553  3 
 
 23554  1 
                             SEPARATOR660=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6562);
 23555  1 
                             stream_SEPARATOR.add(SEPARATOR660);
 23556   
 
 23557   
 
 23558  1 
                             EQUAL661=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6564);
 23559  1 
                             stream_EQUAL.add(EQUAL661);
 23560   
 
 23561   
 
 23562  1 
                             pushFollow(FOLLOW_string_in_aggregate6566);
 23563  4 
                             string662=string();
 23564  3 
 
 23565  1 
                             state._fsp--;
 23566  3 
 
 23567  1 
                             stream_string.add(string662.getTree());
 23568   
 
 23569   
                             }
 23570   
                             break;
 23571  3 
 
 23572  3 
                     }
 23573   
 
 23574   
 
 23575  3 
                     CLOSE_BRACE663=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6570);
 23576  3 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE663);
 23577  3 
 
 23578   
 
 23579   
                     // AST REWRITE
 23580   
                     // elements: DISTINCT, string, expression, GROUP_CONCAT
 23581   
                     // token labels:
 23582   
                     // rule labels: retval
 23583  3 
                     // token list labels:
 23584   
                     // rule list labels:
 23585  3 
                     // wildcard labels:
 23586  3 
                     retval.tree = root_0;
 23587  3 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23588  4 
 
 23589  4 
                     root_0 = (Object)adaptor.nil();
 23590   
                     // 619:100: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23591   
                     {
 23592  3 
                         // com\\googlecode\\sparkleg\\Sparql.g:619:103: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23593   
                         {
 23594  6 
                         Object root_1 = (Object)adaptor.nil();
 23595  3 
                         root_1 = (Object)adaptor.becomeRoot(
 23596   
                         stream_GROUP_CONCAT.nextNode()
 23597   
                         , root_1);
 23598   
 
 23599   
                         // com\\googlecode\\sparkleg\\Sparql.g:619:118: ( DISTINCT )*
 23600  6 
                         while ( stream_DISTINCT.hasNext() ) {
 23601  0 
                             adaptor.addChild(root_1,
 23602   
                             stream_DISTINCT.nextNode()
 23603   
                             );
 23604   
 
 23605   
                         }
 23606  56 
                         stream_DISTINCT.reset();
 23607   
 
 23608  3 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23609  53 
 
 23610  53 
                         // com\\googlecode\\sparkleg\\Sparql.g:619:139: ( string )*
 23611  4 
                         while ( stream_string.hasNext() ) {
 23612  1 
                             adaptor.addChild(root_1, stream_string.nextTree());
 23613   
 
 23614   
                         }
 23615  3 
                         stream_string.reset();
 23616   
 
 23617  3 
                         adaptor.addChild(root_0, root_1);
 23618   
                         }
 23619   
 
 23620   
                     }
 23621   
 
 23622  53 
 
 23623  56 
                     retval.tree = root_0;
 23624   
 
 23625   
                     }
 23626   
                     break;
 23627   
 
 23628  89 
             }
 23629  53 
             retval.stop = input.LT(-1);
 23630  89 
 
 23631   
 
 23632  53 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23633  53 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23634   
 
 23635   
         }
 23636  0 
         catch (RecognitionException re) {
 23637  89 
             reportError(re);
 23638  89 
             recover(input,re);
 23639  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23640   
 
 23641  89 
         }
 23642   
 
 23643  89 
         finally {
 23644   
                 // do for sure before leaving
 23645  142 
         }
 23646  53 
         return retval;
 23647   
     }
 23648  89 
     // $ANTLR end "aggregate"
 23649  89 
 
 23650   
 
 23651  89 
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 23652   
         Object tree;
 23653  89 
         public Object getTree() { return tree; }
 23654  89 
     };
 23655  89 
 
 23656   
 
 23657  89 
     // $ANTLR start "iriRefOrFunction"
 23658   
     // com\\googlecode\\sparkleg\\Sparql.g:622:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 23659  89 
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 23660  89 
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 23661  89 
         retval.start = input.LT(1);
 23662  89 
 
 23663  89 
 
 23664  89 
         Object root_0 = null;
 23665   
 
 23666  113 
         SparqlParser.iriRef_return iriRef664 =null;
 23667   
 
 23668  89 
         SparqlParser.argList_return argList665 =null;
 23669   
 
 23670   
 
 23671  178 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 23672  89 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 23673   
         try {
 23674   
             // com\\googlecode\\sparkleg\\Sparql.g:623:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 23675  24 
             // com\\googlecode\\sparkleg\\Sparql.g:623:7: iriRef ( argList )?
 23676  24 
             {
 23677  89 
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6605);
 23678  113 
             iriRef664=iriRef();
 23679   
 
 23680  113 
             state._fsp--;
 23681   
 
 23682  89 
             stream_iriRef.add(iriRef664.getTree());
 23683   
 
 23684   
             // com\\googlecode\\sparkleg\\Sparql.g:623:14: ( argList )?
 23685  89 
             int alt139=2;
 23686  89 
             switch ( input.LA(1) ) {
 23687   
                 case OPEN_BRACE:
 23688   
                     {
 23689  24 
                     alt139=1;
 23690   
                     }
 23691   
                     break;
 23692   
             }
 23693   
 
 23694  89 
             switch (alt139) {
 23695  89 
                 case 1 :
 23696  89 
                     // com\\googlecode\\sparkleg\\Sparql.g:623:14: argList
 23697   
                     {
 23698  113 
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6607);
 23699  24 
                     argList665=argList();
 23700   
 
 23701  24 
                     state._fsp--;
 23702   
 
 23703  113 
                     stream_argList.add(argList665.getTree());
 23704  89 
 
 23705   
                     }
 23706   
                     break;
 23707   
 
 23708  89 
             }
 23709   
 
 23710   
 
 23711  89 
             // AST REWRITE
 23712   
             // elements: argList, iriRef
 23713   
             // token labels:
 23714  24 
             // rule labels: retval
 23715  24 
             // token list labels:
 23716   
             // rule list labels:
 23717   
             // wildcard labels:
 23718  89 
             retval.tree = root_0;
 23719  113 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23720   
 
 23721  113 
             root_0 = (Object)adaptor.nil();
 23722   
             // 623:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23723   
             {
 23724   
                 // com\\googlecode\\sparkleg\\Sparql.g:623:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23725  89 
                 {
 23726  89 
                 Object root_1 = (Object)adaptor.nil();
 23727  178 
                 root_1 = (Object)adaptor.becomeRoot(
 23728   
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 23729   
                 , root_1);
 23730   
 
 23731  89 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 23732   
 
 23733  89 
                 // com\\googlecode\\sparkleg\\Sparql.g:623:44: ( ^( ARG_LIST argList ) )?
 23734  89 
                 if ( stream_argList.hasNext() ) {
 23735   
                     // com\\googlecode\\sparkleg\\Sparql.g:623:44: ^( ARG_LIST argList )
 23736   
                     {
 23737  113 
                     Object root_2 = (Object)adaptor.nil();
 23738  24 
                     root_2 = (Object)adaptor.becomeRoot(
 23739   
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 23740  89 
                     , root_2);
 23741  89 
 
 23742  24 
                     adaptor.addChild(root_2, stream_argList.nextTree());
 23743   
 
 23744  24 
                     adaptor.addChild(root_1, root_2);
 23745   
                     }
 23746   
 
 23747   
                 }
 23748  89 
                 stream_argList.reset();
 23749   
 
 23750  89 
                 adaptor.addChild(root_0, root_1);
 23751   
                 }
 23752   
 
 23753  89 
             }
 23754  89 
 
 23755   
 
 23756  89 
             retval.tree = root_0;
 23757   
 
 23758   
             }
 23759  189 
 
 23760  89 
             retval.stop = input.LT(-1);
 23761  189 
 
 23762   
 
 23763  89 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23764  89 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23765   
 
 23766   
         }
 23767  0 
         catch (RecognitionException re) {
 23768  189 
             reportError(re);
 23769  189 
             recover(input,re);
 23770  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23771   
 
 23772  189 
         }
 23773   
 
 23774  189 
         finally {
 23775  189 
                 // do for sure before leaving
 23776  278 
         }
 23777  89 
         return retval;
 23778  189 
     }
 23779   
     // $ANTLR end "iriRefOrFunction"
 23780   
 
 23781  189 
 
 23782  189 
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 23783   
         Object tree;
 23784  189 
         public Object getTree() { return tree; }
 23785   
     };
 23786   
 
 23787   
 
 23788  189 
     // $ANTLR start "rdfLiteral"
 23789   
     // com\\googlecode\\sparkleg\\Sparql.g:626:1: rdfLiteral : string ( LANGTAG | ( REFERENCE iriRef ) )? ;
 23790   
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 23791  378 
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 23792  378 
         retval.start = input.LT(1);
 23793   
 
 23794  189 
 
 23795  189 
         Object root_0 = null;
 23796  189 
 
 23797  189 
         Token LANGTAG667=null;
 23798  189 
         Token REFERENCE668=null;
 23799  378 
         SparqlParser.string_return string666 =null;
 23800  189 
 
 23801  189 
         SparqlParser.iriRef_return iriRef669 =null;
 23802   
 
 23803  5 
 
 23804  189 
         Object LANGTAG667_tree=null;
 23805  194 
         Object REFERENCE668_tree=null;
 23806   
 
 23807   
         try {
 23808  19 
             // com\\googlecode\\sparkleg\\Sparql.g:627:5: ( string ( LANGTAG | ( REFERENCE iriRef ) )? )
 23809   
             // com\\googlecode\\sparkleg\\Sparql.g:627:7: string ( LANGTAG | ( REFERENCE iriRef ) )?
 23810   
             {
 23811  189 
             root_0 = (Object)adaptor.nil();
 23812   
 
 23813  189 
 
 23814  189 
             pushFollow(FOLLOW_string_in_rdfLiteral6640);
 23815  189 
             string666=string();
 23816   
 
 23817  194 
             state._fsp--;
 23818  5 
 
 23819  189 
             adaptor.addChild(root_0, string666.getTree());
 23820   
 
 23821  5 
             // com\\googlecode\\sparkleg\\Sparql.g:627:14: ( LANGTAG | ( REFERENCE iriRef ) )?
 23822  189 
             int alt140=3;
 23823  189 
             switch ( input.LA(1) ) {
 23824   
                 case LANGTAG:
 23825  5 
                     {
 23826  5 
                     alt140=1;
 23827   
                     }
 23828  5 
                     break;
 23829   
                 case REFERENCE:
 23830   
                     {
 23831  19 
                     alt140=2;
 23832  19 
                     }
 23833  19 
                     break;
 23834   
             }
 23835   
 
 23836  208 
             switch (alt140) {
 23837   
                 case 1 :
 23838   
                     // com\\googlecode\\sparkleg\\Sparql.g:627:15: LANGTAG
 23839  19 
                     {
 23840  24 
                     LANGTAG667=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6643);
 23841  5 
                     LANGTAG667_tree =
 23842  19 
                     (Object)adaptor.create(LANGTAG667)
 23843   
                     ;
 23844  24 
                     adaptor.addChild(root_0, LANGTAG667_tree);
 23845   
 
 23846   
 
 23847   
                     }
 23848  5 
                     break;
 23849   
                 case 2 :
 23850   
                     // com\\googlecode\\sparkleg\\Sparql.g:627:25: ( REFERENCE iriRef )
 23851   
                     {
 23852   
                     // com\\googlecode\\sparkleg\\Sparql.g:627:25: ( REFERENCE iriRef )
 23853   
                     // com\\googlecode\\sparkleg\\Sparql.g:627:26: REFERENCE iriRef
 23854   
                     {
 23855  19 
                     REFERENCE668=(Token)match(input,REFERENCE,FOLLOW_REFERENCE_in_rdfLiteral6648);
 23856  19 
                     REFERENCE668_tree =
 23857  189 
                     (Object)adaptor.create(REFERENCE668)
 23858   
                     ;
 23859  19 
                     adaptor.addChild(root_0, REFERENCE668_tree);
 23860  189 
 
 23861  189 
 
 23862  19 
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6650);
 23863  19 
                     iriRef669=iriRef();
 23864   
 
 23865  19 
                     state._fsp--;
 23866   
 
 23867  19 
                     adaptor.addChild(root_0, iriRef669.getTree());
 23868   
 
 23869   
                     }
 23870   
 
 23871   
 
 23872   
                     }
 23873  189 
                     break;
 23874  189 
 
 23875   
             }
 23876   
 
 23877   
 
 23878   
             }
 23879  141 
 
 23880  189 
             retval.stop = input.LT(-1);
 23881  141 
 
 23882   
 
 23883  189 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23884  189 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23885   
 
 23886   
         }
 23887  0 
         catch (RecognitionException re) {
 23888  141 
             reportError(re);
 23889  141 
             recover(input,re);
 23890  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23891   
 
 23892  141 
         }
 23893   
 
 23894  141 
         finally {
 23895   
                 // do for sure before leaving
 23896  330 
         }
 23897  189 
         return retval;
 23898  141 
     }
 23899   
     // $ANTLR end "rdfLiteral"
 23900   
 
 23901   
 
 23902  141 
     public static class numericLiteral_return extends ParserRuleReturnScope {
 23903   
         Object tree;
 23904  141 
         public Object getTree() { return tree; }
 23905  141 
     };
 23906   
 
 23907   
 
 23908   
     // $ANTLR start "numericLiteral"
 23909   
     // com\\googlecode\\sparkleg\\Sparql.g:630:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 23910  128 
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 23911  141 
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 23912  269 
         retval.start = input.LT(1);
 23913   
 
 23914   
 
 23915  141 
         Object root_0 = null;
 23916   
 
 23917  146 
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned670 =null;
 23918   
 
 23919  146 
         SparqlParser.numericLiteralPositive_return numericLiteralPositive671 =null;
 23920   
 
 23921  141 
         SparqlParser.numericLiteralNegative_return numericLiteralNegative672 =null;
 23922   
 
 23923   
 
 23924  8 
 
 23925   
         try {
 23926  8 
             // com\\googlecode\\sparkleg\\Sparql.g:631:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 23927  141 
             int alt141=3;
 23928  141 
             switch ( input.LA(1) ) {
 23929   
             case DECIMAL:
 23930   
             case DOUBLE:
 23931   
             case INTEGER:
 23932   
                 {
 23933  128 
                 alt141=1;
 23934   
                 }
 23935  269 
                 break;
 23936   
             case DECIMAL_POSITIVE:
 23937   
             case DOUBLE_POSITIVE:
 23938   
             case INTEGER_POSITIVE:
 23939  128 
                 {
 23940  5 
                 alt141=2;
 23941   
                 }
 23942  133 
                 break;
 23943  128 
             case DECIMAL_NEGATIVE:
 23944   
             case DOUBLE_NEGATIVE:
 23945  128 
             case INTEGER_NEGATIVE:
 23946   
                 {
 23947  136 
                 alt141=3;
 23948   
                 }
 23949  8 
                 break;
 23950  128 
             default:
 23951  0 
                 NoViableAltException nvae =
 23952   
                     new NoViableAltException("", 141, 0, input);
 23953   
 
 23954  5 
                 throw nvae;
 23955   
 
 23956   
             }
 23957  5 
 
 23958  146 
             switch (alt141) {
 23959   
                 case 1 :
 23960  5 
                     // com\\googlecode\\sparkleg\\Sparql.g:631:7: numericLiteralUnsigned
 23961   
                     {
 23962  133 
                     root_0 = (Object)adaptor.nil();
 23963   
 
 23964   
 
 23965  133 
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6670);
 23966  128 
                     numericLiteralUnsigned670=numericLiteralUnsigned();
 23967   
 
 23968  128 
                     state._fsp--;
 23969  8 
 
 23970  128 
                     adaptor.addChild(root_0, numericLiteralUnsigned670.getTree());
 23971   
 
 23972  8 
                     }
 23973  136 
                     break;
 23974   
                 case 2 :
 23975  8 
                     // com\\googlecode\\sparkleg\\Sparql.g:632:7: numericLiteralPositive
 23976   
                     {
 23977  13 
                     root_0 = (Object)adaptor.nil();
 23978   
 
 23979   
 
 23980  5 
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6678);
 23981  5 
                     numericLiteralPositive671=numericLiteralPositive();
 23982   
 
 23983  146 
                     state._fsp--;
 23984   
 
 23985  5 
                     adaptor.addChild(root_0, numericLiteralPositive671.getTree());
 23986  141 
 
 23987  141 
                     }
 23988  5 
                     break;
 23989   
                 case 3 :
 23990   
                     // com\\googlecode\\sparkleg\\Sparql.g:633:7: numericLiteralNegative
 23991   
                     {
 23992  8 
                     root_0 = (Object)adaptor.nil();
 23993   
 
 23994   
 
 23995  8 
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6686);
 23996  8 
                     numericLiteralNegative672=numericLiteralNegative();
 23997   
 
 23998  8 
                     state._fsp--;
 23999  141 
 
 24000  149 
                     adaptor.addChild(root_0, numericLiteralNegative672.getTree());
 24001   
 
 24002   
                     }
 24003   
                     break;
 24004   
 
 24005  128 
             }
 24006  141 
             retval.stop = input.LT(-1);
 24007  128 
 
 24008   
 
 24009  141 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24010  141 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24011   
 
 24012   
         }
 24013  0 
         catch (RecognitionException re) {
 24014  128 
             reportError(re);
 24015  128 
             recover(input,re);
 24016  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24017   
 
 24018  128 
         }
 24019   
 
 24020  128 
         finally {
 24021   
                 // do for sure before leaving
 24022  269 
         }
 24023  141 
         return retval;
 24024   
     }
 24025   
     // $ANTLR end "numericLiteral"
 24026   
 
 24027   
 
 24028  128 
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24029   
         Object tree;
 24030  128 
         public Object getTree() { return tree; }
 24031  128 
     };
 24032   
 
 24033  128 
 
 24034  128 
     // $ANTLR start "numericLiteralUnsigned"
 24035  128 
     // com\\googlecode\\sparkleg\\Sparql.g:636:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24036   
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24037  128 
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24038  256 
         retval.start = input.LT(1);
 24039   
 
 24040   
 
 24041  128 
         Object root_0 = null;
 24042   
 
 24043  128 
         Token set673=null;
 24044   
 
 24045  128 
         Object set673_tree=null;
 24046   
 
 24047   
         try {
 24048  128 
             // com\\googlecode\\sparkleg\\Sparql.g:637:5: ( INTEGER | DECIMAL | DOUBLE )
 24049   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24050   
             {
 24051  256 
             root_0 = (Object)adaptor.nil();
 24052  128 
 
 24053   
 
 24054  128 
             set673=(Token)input.LT(1);
 24055   
 
 24056  128 
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24057  128 
                 input.consume();
 24058  128 
                 adaptor.addChild(root_0,
 24059   
                 (Object)adaptor.create(set673)
 24060   
                 );
 24061  128 
                 state.errorRecovery=false;
 24062   
             }
 24063   
             else {
 24064  128 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24065  128 
                 throw mse;
 24066   
             }
 24067   
 
 24068   
 
 24069   
             }
 24070  25 
 
 24071  128 
             retval.stop = input.LT(-1);
 24072  25 
 
 24073   
 
 24074  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24075  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24076   
 
 24077   
         }
 24078  0 
         catch (RecognitionException re) {
 24079  25 
             reportError(re);
 24080  25 
             recover(input,re);
 24081  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24082   
 
 24083  25 
         }
 24084   
 
 24085  25 
         finally {
 24086   
                 // do for sure before leaving
 24087  153 
         }
 24088  128 
         return retval;
 24089   
     }
 24090   
     // $ANTLR end "numericLiteralUnsigned"
 24091   
 
 24092   
 
 24093  25 
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24094   
         Object tree;
 24095  25 
         public Object getTree() { return tree; }
 24096  25 
     };
 24097   
 
 24098  25 
 
 24099  25 
     // $ANTLR start "numericLiteralPositive"
 24100  25 
     // com\\googlecode\\sparkleg\\Sparql.g:642:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24101   
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24102  25 
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24103  50 
         retval.start = input.LT(1);
 24104   
 
 24105   
 
 24106  25 
         Object root_0 = null;
 24107   
 
 24108  25 
         Token set674=null;
 24109   
 
 24110  25 
         Object set674_tree=null;
 24111   
 
 24112   
         try {
 24113  25 
             // com\\googlecode\\sparkleg\\Sparql.g:643:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24114   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24115   
             {
 24116  50 
             root_0 = (Object)adaptor.nil();
 24117  25 
 
 24118   
 
 24119  25 
             set674=(Token)input.LT(1);
 24120   
 
 24121  25 
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24122  25 
                 input.consume();
 24123  25 
                 adaptor.addChild(root_0,
 24124   
                 (Object)adaptor.create(set674)
 24125   
                 );
 24126  25 
                 state.errorRecovery=false;
 24127   
             }
 24128   
             else {
 24129  25 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24130  25 
                 throw mse;
 24131   
             }
 24132   
 
 24133   
 
 24134   
             }
 24135  8 
 
 24136  25 
             retval.stop = input.LT(-1);
 24137  8 
 
 24138   
 
 24139  25 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24140  25 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24141   
 
 24142   
         }
 24143  0 
         catch (RecognitionException re) {
 24144  8 
             reportError(re);
 24145  8 
             recover(input,re);
 24146  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24147   
 
 24148  8 
         }
 24149   
 
 24150  8 
         finally {
 24151   
                 // do for sure before leaving
 24152  33 
         }
 24153  25 
         return retval;
 24154   
     }
 24155   
     // $ANTLR end "numericLiteralPositive"
 24156   
 
 24157   
 
 24158  8 
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24159   
         Object tree;
 24160  8 
         public Object getTree() { return tree; }
 24161  8 
     };
 24162   
 
 24163  8 
 
 24164  8 
     // $ANTLR start "numericLiteralNegative"
 24165  8 
     // com\\googlecode\\sparkleg\\Sparql.g:648:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24166   
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24167  8 
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24168  16 
         retval.start = input.LT(1);
 24169   
 
 24170   
 
 24171  8 
         Object root_0 = null;
 24172   
 
 24173  8 
         Token set675=null;
 24174   
 
 24175  8 
         Object set675_tree=null;
 24176   
 
 24177   
         try {
 24178  8 
             // com\\googlecode\\sparkleg\\Sparql.g:649:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24179   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24180   
             {
 24181  16 
             root_0 = (Object)adaptor.nil();
 24182  8 
 
 24183   
 
 24184  8 
             set675=(Token)input.LT(1);
 24185   
 
 24186  8 
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24187  8 
                 input.consume();
 24188  8 
                 adaptor.addChild(root_0,
 24189   
                 (Object)adaptor.create(set675)
 24190   
                 );
 24191  8 
                 state.errorRecovery=false;
 24192   
             }
 24193   
             else {
 24194  8 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24195  8 
                 throw mse;
 24196   
             }
 24197   
 
 24198   
 
 24199   
             }
 24200  8 
 
 24201  8 
             retval.stop = input.LT(-1);
 24202  8 
 
 24203   
 
 24204  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24205  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24206   
 
 24207   
         }
 24208  0 
         catch (RecognitionException re) {
 24209  8 
             reportError(re);
 24210  8 
             recover(input,re);
 24211  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24212   
 
 24213  8 
         }
 24214   
 
 24215  8 
         finally {
 24216   
                 // do for sure before leaving
 24217  16 
         }
 24218  8 
         return retval;
 24219   
     }
 24220   
     // $ANTLR end "numericLiteralNegative"
 24221   
 
 24222   
 
 24223  8 
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24224   
         Object tree;
 24225  8 
         public Object getTree() { return tree; }
 24226  8 
     };
 24227   
 
 24228  8 
 
 24229  8 
     // $ANTLR start "booleanLiteral"
 24230  8 
     // com\\googlecode\\sparkleg\\Sparql.g:654:1: booleanLiteral : ( TRUE | FALSE );
 24231   
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24232  8 
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24233  16 
         retval.start = input.LT(1);
 24234   
 
 24235   
 
 24236  8 
         Object root_0 = null;
 24237   
 
 24238  8 
         Token set676=null;
 24239   
 
 24240  8 
         Object set676_tree=null;
 24241   
 
 24242   
         try {
 24243  8 
             // com\\googlecode\\sparkleg\\Sparql.g:655:5: ( TRUE | FALSE )
 24244   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24245   
             {
 24246  16 
             root_0 = (Object)adaptor.nil();
 24247  8 
 
 24248   
 
 24249  8 
             set676=(Token)input.LT(1);
 24250   
 
 24251  8 
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24252  8 
                 input.consume();
 24253  8 
                 adaptor.addChild(root_0,
 24254   
                 (Object)adaptor.create(set676)
 24255   
                 );
 24256  8 
                 state.errorRecovery=false;
 24257   
             }
 24258   
             else {
 24259  8 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24260  8 
                 throw mse;
 24261   
             }
 24262   
 
 24263   
 
 24264   
             }
 24265  190 
 
 24266  8 
             retval.stop = input.LT(-1);
 24267  190 
 
 24268   
 
 24269  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24270  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24271   
 
 24272   
         }
 24273  0 
         catch (RecognitionException re) {
 24274  190 
             reportError(re);
 24275  190 
             recover(input,re);
 24276  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24277   
 
 24278  190 
         }
 24279   
 
 24280  190 
         finally {
 24281   
                 // do for sure before leaving
 24282  198 
         }
 24283  8 
         return retval;
 24284   
     }
 24285   
     // $ANTLR end "booleanLiteral"
 24286   
 
 24287   
 
 24288  190 
     public static class string_return extends ParserRuleReturnScope {
 24289   
         Object tree;
 24290  190 
         public Object getTree() { return tree; }
 24291  190 
     };
 24292   
 
 24293  190 
 
 24294  190 
     // $ANTLR start "string"
 24295  190 
     // com\\googlecode\\sparkleg\\Sparql.g:659:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24296   
     public final SparqlParser.string_return string() throws RecognitionException {
 24297  190 
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24298  380 
         retval.start = input.LT(1);
 24299   
 
 24300   
 
 24301  190 
         Object root_0 = null;
 24302   
 
 24303  190 
         Token set677=null;
 24304   
 
 24305  190 
         Object set677_tree=null;
 24306   
 
 24307   
         try {
 24308  190 
             // com\\googlecode\\sparkleg\\Sparql.g:660:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24309   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24310   
             {
 24311  380 
             root_0 = (Object)adaptor.nil();
 24312  190 
 
 24313   
 
 24314  190 
             set677=(Token)input.LT(1);
 24315   
 
 24316  190 
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24317  190 
                 input.consume();
 24318  190 
                 adaptor.addChild(root_0,
 24319   
                 (Object)adaptor.create(set677)
 24320   
                 );
 24321  190 
                 state.errorRecovery=false;
 24322   
             }
 24323   
             else {
 24324  190 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24325  190 
                 throw mse;
 24326   
             }
 24327   
 
 24328   
 
 24329   
             }
 24330  2177 
 
 24331  190 
             retval.stop = input.LT(-1);
 24332  2177 
 
 24333   
 
 24334  190 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24335  190 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24336   
 
 24337   
         }
 24338  0 
         catch (RecognitionException re) {
 24339  2177 
             reportError(re);
 24340  2177 
             recover(input,re);
 24341  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24342   
 
 24343  2177 
         }
 24344   
 
 24345  2177 
         finally {
 24346  2177 
                 // do for sure before leaving
 24347  190 
         }
 24348  190 
         return retval;
 24349  2177 
     }
 24350   
     // $ANTLR end "string"
 24351   
 
 24352   
 
 24353  2177 
     public static class iriRef_return extends ParserRuleReturnScope {
 24354  2177 
         Object tree;
 24355  2177 
         public Object getTree() { return tree; }
 24356   
     };
 24357  237 
 
 24358   
 
 24359  237 
     // $ANTLR start "iriRef"
 24360   
     // com\\googlecode\\sparkleg\\Sparql.g:666:1: iriRef : ( IRI_REF | prefixedName );
 24361   
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24362  2177 
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24363  4117 
         retval.start = input.LT(1);
 24364   
 
 24365  1940 
 
 24366  2177 
         Object root_0 = null;
 24367   
 
 24368  2177 
         Token IRI_REF678=null;
 24369  2177 
         SparqlParser.prefixedName_return prefixedName679 =null;
 24370   
 
 24371   
 
 24372  2177 
         Object IRI_REF678_tree=null;
 24373   
 
 24374  2177 
         try {
 24375   
             // com\\googlecode\\sparkleg\\Sparql.g:667:5: ( IRI_REF | prefixedName )
 24376  2177 
             int alt142=2;
 24377  2177 
             switch ( input.LA(1) ) {
 24378  237 
             case IRI_REF:
 24379   
                 {
 24380  237 
                 alt142=1;
 24381  237 
                 }
 24382  474 
                 break;
 24383   
             case PNAME_LN:
 24384   
             case PNAME_NS:
 24385  237 
                 {
 24386  1940 
                 alt142=2;
 24387   
                 }
 24388  1940 
                 break;
 24389  237 
             default:
 24390  0 
                 NoViableAltException nvae =
 24391   
                     new NoViableAltException("", 142, 0, input);
 24392   
 
 24393  1940 
                 throw nvae;
 24394   
 
 24395   
             }
 24396  1940 
 
 24397  4117 
             switch (alt142) {
 24398   
                 case 1 :
 24399  1940 
                     // com\\googlecode\\sparkleg\\Sparql.g:667:7: IRI_REF
 24400   
                     {
 24401  2177 
                     root_0 = (Object)adaptor.nil();
 24402   
 
 24403   
 
 24404  237 
                     IRI_REF678=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef6869);
 24405  237 
                     IRI_REF678_tree =
 24406   
                     (Object)adaptor.create(IRI_REF678)
 24407  2177 
                     ;
 24408  237 
                     adaptor.addChild(root_0, IRI_REF678_tree);
 24409   
 
 24410  2177 
 
 24411  2177 
                     }
 24412  237 
                     break;
 24413   
                 case 2 :
 24414   
                     // com\\googlecode\\sparkleg\\Sparql.g:668:7: prefixedName
 24415   
                     {
 24416  1940 
                     root_0 = (Object)adaptor.nil();
 24417   
 
 24418   
 
 24419  1940 
                     pushFollow(FOLLOW_prefixedName_in_iriRef6877);
 24420  1940 
                     prefixedName679=prefixedName();
 24421   
 
 24422  1940 
                     state._fsp--;
 24423  2177 
 
 24424  4117 
                     adaptor.addChild(root_0, prefixedName679.getTree());
 24425   
 
 24426   
                     }
 24427   
                     break;
 24428   
 
 24429  1940 
             }
 24430  2177 
             retval.stop = input.LT(-1);
 24431  1940 
 
 24432   
 
 24433  2177 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24434  2177 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24435   
 
 24436   
         }
 24437  0 
         catch (RecognitionException re) {
 24438  1940 
             reportError(re);
 24439  1940 
             recover(input,re);
 24440  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24441   
 
 24442  1940 
         }
 24443   
 
 24444  1940 
         finally {
 24445   
                 // do for sure before leaving
 24446  4117 
         }
 24447  2177 
         return retval;
 24448   
     }
 24449   
     // $ANTLR end "iriRef"
 24450   
 
 24451   
 
 24452  1940 
     public static class prefixedName_return extends ParserRuleReturnScope {
 24453   
         Object tree;
 24454  1940 
         public Object getTree() { return tree; }
 24455  1940 
     };
 24456   
 
 24457  1940 
 
 24458  1940 
     // $ANTLR start "prefixedName"
 24459  1940 
     // com\\googlecode\\sparkleg\\Sparql.g:671:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24460   
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24461  1940 
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24462  3880 
         retval.start = input.LT(1);
 24463   
 
 24464   
 
 24465  1940 
         Object root_0 = null;
 24466   
 
 24467  1940 
         Token set680=null;
 24468   
 
 24469  1940 
         Object set680_tree=null;
 24470   
 
 24471   
         try {
 24472  1940 
             // com\\googlecode\\sparkleg\\Sparql.g:672:5: ( PNAME_LN | PNAME_NS )
 24473   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24474   
             {
 24475  3880 
             root_0 = (Object)adaptor.nil();
 24476  1940 
 
 24477   
 
 24478  1940 
             set680=(Token)input.LT(1);
 24479   
 
 24480  1940 
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24481  1940 
                 input.consume();
 24482  1940 
                 adaptor.addChild(root_0,
 24483   
                 (Object)adaptor.create(set680)
 24484   
                 );
 24485  1940 
                 state.errorRecovery=false;
 24486   
             }
 24487   
             else {
 24488  1940 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24489  1940 
                 throw mse;
 24490   
             }
 24491   
 
 24492   
 
 24493   
             }
 24494  102 
 
 24495  1940 
             retval.stop = input.LT(-1);
 24496  102 
 
 24497   
 
 24498  1940 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24499  1940 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24500   
 
 24501   
         }
 24502  0 
         catch (RecognitionException re) {
 24503  102 
             reportError(re);
 24504  102 
             recover(input,re);
 24505  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24506   
 
 24507  102 
         }
 24508   
 
 24509  102 
         finally {
 24510  102 
                 // do for sure before leaving
 24511  1940 
         }
 24512  1940 
         return retval;
 24513  102 
     }
 24514   
     // $ANTLR end "prefixedName"
 24515   
 
 24516   
 
 24517  102 
     public static class blankNode_return extends ParserRuleReturnScope {
 24518  102 
         Object tree;
 24519  102 
         public Object getTree() { return tree; }
 24520   
     };
 24521  58 
 
 24522   
 
 24523  58 
     // $ANTLR start "blankNode"
 24524   
     // com\\googlecode\\sparkleg\\Sparql.g:676:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24525   
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24526  146 
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24527  102 
         retval.start = input.LT(1);
 24528  44 
 
 24529   
 
 24530  102 
         Object root_0 = null;
 24531   
 
 24532  102 
         Token BLANK_NODE_LABEL681=null;
 24533  102 
         SparqlParser.anon_return anon682 =null;
 24534   
 
 24535   
 
 24536  102 
         Object BLANK_NODE_LABEL681_tree=null;
 24537  102 
 
 24538   
         try {
 24539   
             // com\\googlecode\\sparkleg\\Sparql.g:677:5: ( BLANK_NODE_LABEL | anon )
 24540  102 
             int alt143=2;
 24541  160 
             switch ( input.LA(1) ) {
 24542   
             case BLANK_NODE_LABEL:
 24543   
                 {
 24544  116 
                 alt143=1;
 24545  58 
                 }
 24546  58 
                 break;
 24547   
             case OPEN_SQUARE_BRACKET:
 24548  58 
                 {
 24549  44 
                 alt143=2;
 24550   
                 }
 24551  44 
                 break;
 24552  58 
             default:
 24553  0 
                 NoViableAltException nvae =
 24554   
                     new NoViableAltException("", 143, 0, input);
 24555   
 
 24556  44 
                 throw nvae;
 24557   
 
 24558   
             }
 24559  44 
 
 24560  146 
             switch (alt143) {
 24561   
                 case 1 :
 24562  44 
                     // com\\googlecode\\sparkleg\\Sparql.g:677:7: BLANK_NODE_LABEL
 24563   
                     {
 24564  102 
                     root_0 = (Object)adaptor.nil();
 24565   
 
 24566   
 
 24567  58 
                     BLANK_NODE_LABEL681=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode6919);
 24568  58 
                     BLANK_NODE_LABEL681_tree =
 24569   
                     (Object)adaptor.create(BLANK_NODE_LABEL681)
 24570  102 
                     ;
 24571  58 
                     adaptor.addChild(root_0, BLANK_NODE_LABEL681_tree);
 24572   
 
 24573  102 
 
 24574  102 
                     }
 24575  58 
                     break;
 24576   
                 case 2 :
 24577   
                     // com\\googlecode\\sparkleg\\Sparql.g:678:7: anon
 24578   
                     {
 24579  44 
                     root_0 = (Object)adaptor.nil();
 24580   
 
 24581   
 
 24582  44 
                     pushFollow(FOLLOW_anon_in_blankNode6927);
 24583  44 
                     anon682=anon();
 24584   
 
 24585  44 
                     state._fsp--;
 24586  102 
 
 24587  146 
                     adaptor.addChild(root_0, anon682.getTree());
 24588   
 
 24589   
                     }
 24590   
                     break;
 24591   
 
 24592  44 
             }
 24593  102 
             retval.stop = input.LT(-1);
 24594  44 
 
 24595   
 
 24596  102 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24597  102 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24598   
 
 24599   
         }
 24600  0 
         catch (RecognitionException re) {
 24601  44 
             reportError(re);
 24602  44 
             recover(input,re);
 24603  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24604   
 
 24605  44 
         }
 24606   
 
 24607  44 
         finally {
 24608  44 
                 // do for sure before leaving
 24609  102 
         }
 24610  146 
         return retval;
 24611  44 
     }
 24612   
     // $ANTLR end "blankNode"
 24613   
 
 24614   
 
 24615  44 
     public static class anon_return extends ParserRuleReturnScope {
 24616   
         Object tree;
 24617  44 
         public Object getTree() { return tree; }
 24618   
     };
 24619   
 
 24620  44 
 
 24621  44 
     // $ANTLR start "anon"
 24622   
     // com\\googlecode\\sparkleg\\Sparql.g:681:1: anon : OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET ;
 24623   
     public final SparqlParser.anon_return anon() throws RecognitionException {
 24624  88 
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 24625  44 
         retval.start = input.LT(1);
 24626   
 
 24627  44 
 
 24628  88 
         Object root_0 = null;
 24629   
 
 24630  44 
         Token OPEN_SQUARE_BRACKET683=null;
 24631  88 
         Token CLOSE_SQUARE_BRACKET684=null;
 24632   
 
 24633  44 
         Object OPEN_SQUARE_BRACKET683_tree=null;
 24634  44 
         Object CLOSE_SQUARE_BRACKET684_tree=null;
 24635   
 
 24636  44 
         try {
 24637   
             // com\\googlecode\\sparkleg\\Sparql.g:682:5: ( OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET )
 24638   
             // com\\googlecode\\sparkleg\\Sparql.g:682:7: OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET
 24639  44 
             {
 24640  88 
             root_0 = (Object)adaptor.nil();
 24641   
 
 24642   
 
 24643  44 
             OPEN_SQUARE_BRACKET683=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_anon6944);
 24644  44 
             OPEN_SQUARE_BRACKET683_tree =
 24645   
             (Object)adaptor.create(OPEN_SQUARE_BRACKET683)
 24646   
             ;
 24647  44 
             adaptor.addChild(root_0, OPEN_SQUARE_BRACKET683_tree);
 24648   
 
 24649   
 
 24650  44 
             CLOSE_SQUARE_BRACKET684=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6946);
 24651  44 
             CLOSE_SQUARE_BRACKET684_tree =
 24652  44 
             (Object)adaptor.create(CLOSE_SQUARE_BRACKET684)
 24653  44 
             ;
 24654  44 
             adaptor.addChild(root_0, CLOSE_SQUARE_BRACKET684_tree);
 24655   
 
 24656   
 
 24657   
             }
 24658   
 
 24659  44 
             retval.stop = input.LT(-1);
 24660  979 
 
 24661   
 
 24662  44 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24663  44 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24664   
 
 24665   
         }
 24666  0 
         catch (RecognitionException re) {
 24667  0 
             reportError(re);
 24668  0 
             recover(input,re);
 24669  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24670   
 
 24671   
         }
 24672   
 
 24673  1 
         finally {
 24674   
                 // do for sure before leaving
 24675  44 
         }
 24676  44 
         return retval;
 24677   
     }
 24678   
     // $ANTLR end "anon"
 24679   
 
 24680   
     // Delegated rules
 24681   
 
 24682   
 
 24683  979 
     protected DFA4 dfa4 = new DFA4(this);
 24684   
     static final String DFA4_eotS =
 24685   
         "\10\uffff";
 24686   
     static final String DFA4_eofS =
 24687   
         "\10\uffff";
 24688   
     static final String DFA4_minS =
 24689   
         "\1\6\1\133\1\u008a\2\uffff\1\6\1\133\1\6";
 24690   
     static final String DFA4_maxS =
 24691   
         "\1\u00cf\1\133\1\u008a\2\uffff\1\u00cf\1\133\1\u00cf";
 24692   
     static final String DFA4_acceptS =
 24693  1 
         "\3\uffff\1\1\1\2\3\uffff";
 24694  1 
     static final String DFA4_specialS =
 24695  1 
         "\10\uffff}>";
 24696  2 
     static final String[] DFA4_transitionS = {
 24697  1 
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24698  1 
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24699   
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24700   
             "\uffff\1\4",
 24701   
             "\1\5",
 24702  1 
             "\1\6",
 24703  1 
             "",
 24704  9 
             "",
 24705  8 
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24706   
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24707   
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24708   
             "\uffff\1\4",
 24709   
             "\1\7",
 24710   
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24711  979 
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24712  979 
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24713  979 
             "\uffff\1\4"
 24714  979 
     };
 24715  979 
 
 24716  1 
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 24717  1 
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 24718  1 
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 24719  1 
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 24720  1 
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 24721  1 
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 24722   
     static final short[][] DFA4_transition;
 24723   
 
 24724   
     static {
 24725  1 
         int numStates = DFA4_transitionS.length;
 24726  1 
         DFA4_transition = new short[numStates][];
 24727  9 
         for (int i=0; i<numStates; i++) {
 24728  9 
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 24729  1 
         }
 24730  1 
     }
 24731  1 
 
 24732  1 
     class DFA4 extends DFA {
 24733  1 
 
 24734  1 
         public DFA4(BaseRecognizer recognizer) {
 24735  1 
             this.recognizer = recognizer;
 24736  1 
             this.decisionNumber = 4;
 24737  1 
             this.eot = DFA4_eot;
 24738  1 
             this.eof = DFA4_eof;
 24739  1 
             this.min = DFA4_min;
 24740  1 
             this.max = DFA4_max;
 24741  1 
             this.accept = DFA4_accept;
 24742  1 
             this.special = DFA4_special;
 24743  1 
             this.transition = DFA4_transition;
 24744  1 
         }
 24745  1 
         public String getDescription() {
 24746  1 
             return "76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 24747  1 
         }
 24748  1 
     }
 24749  1 
 
 24750  1 
 
 24751  2 
     public static final BitSet FOLLOW_prologue_in_query155 = new BitSet(new long[]{0x0008001000002000L,0x0000000000000000L,0x0000000040000000L});
 24752  2 
     public static final BitSet FOLLOW_selectQuery_in_query158 = new BitSet(new long[]{0x0000000000040000L});
 24753  2 
     public static final BitSet FOLLOW_constructQuery_in_query162 = new BitSet(new long[]{0x0000000000040000L});
 24754  2 
     public static final BitSet FOLLOW_describeQuery_in_query166 = new BitSet(new long[]{0x0000000000040000L});
 24755  2 
     public static final BitSet FOLLOW_askQuery_in_query170 = new BitSet(new long[]{0x0000000000040000L});
 24756  2 
     public static final BitSet FOLLOW_bindingsClause_in_query173 = new BitSet(new long[]{0x0000000000000000L});
 24757  2 
     public static final BitSet FOLLOW_EOF_in_query175 = new BitSet(new long[]{0x0000000000000002L});
 24758  2 
     public static final BitSet FOLLOW_update_in_query206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24759  2 
     public static final BitSet FOLLOW_SEMICOLON_in_query209 = new BitSet(new long[]{0x0802028008010040L,0x0004020000100000L,0x0000000100020000L,0x0000000000008000L});
 24760  2 
     public static final BitSet FOLLOW_update_in_query211 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24761  2 
     public static final BitSet FOLLOW_EOF_in_query216 = new BitSet(new long[]{0x0000000000000002L});
 24762  2 
     public static final BitSet FOLLOW_baseDecl_in_prologue249 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24763  2 
     public static final BitSet FOLLOW_prefixDecl_in_prologue253 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24764  2 
     public static final BitSet FOLLOW_BASE_in_baseDecl284 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24765  2 
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl286 = new BitSet(new long[]{0x0000000000000002L});
 24766  2 
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
 24767  2 
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl314 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24768  2 
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl316 = new BitSet(new long[]{0x0000000000000002L});
 24769  2 
     public static final BitSet FOLLOW_selectClause_in_selectQuery343 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24770  2 
     public static final BitSet FOLLOW_datasetClause_in_selectQuery345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24771  2 
     public static final BitSet FOLLOW_whereClause_in_selectQuery348 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24772  2 
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery350 = new BitSet(new long[]{0x0000000000000002L});
 24773  2 
     public static final BitSet FOLLOW_selectClause_in_subSelect384 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24774  2 
     public static final BitSet FOLLOW_whereClause_in_subSelect386 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24775  2 
     public static final BitSet FOLLOW_solutionModifier_in_subSelect388 = new BitSet(new long[]{0x0000000000000002L});
 24776  2 
     public static final BitSet FOLLOW_SELECT_in_selectClause424 = new BitSet(new long[]{0x0020000000004000L,0x0000000000000000L,0x0000000000400000L});
 24777  2 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause427 = new BitSet(new long[]{0x0000000000004000L});
 24778  2 
     public static final BitSet FOLLOW_REDUCED_in_selectClause431 = new BitSet(new long[]{0x0000000000004000L});
 24779  2 
     public static final BitSet FOLLOW_ASTERISK_in_selectClause435 = new BitSet(new long[]{0x0000000000000002L});
 24780  2 
     public static final BitSet FOLLOW_SELECT_in_selectClause457 = new BitSet(new long[]{0x0020000000000000L,0x0800000000000000L,0x0000000000400000L,0x0000000000000C00L});
 24781  2 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24782  2 
     public static final BitSet FOLLOW_REDUCED_in_selectClause464 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24783  2 
     public static final BitSet FOLLOW_selectVariables_in_selectClause471 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24784  2 
     public static final BitSet FOLLOW_var_in_selectVariables506 = new BitSet(new long[]{0x0000000000000002L});
 24785  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_selectVariables523 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24786  2 
     public static final BitSet FOLLOW_expression_in_selectVariables525 = new BitSet(new long[]{0x0000000000000800L});
 24787  2 
     public static final BitSet FOLLOW_AS_in_selectVariables527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24788  2 
     public static final BitSet FOLLOW_var_in_selectVariables529 = new BitSet(new long[]{0x0000000010000000L});
 24789  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_selectVariables531 = new BitSet(new long[]{0x0000000000000002L});
 24790  2 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery558 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24791  2 
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery560 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24792  2 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery562 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24793  2 
     public static final BitSet FOLLOW_whereClause_in_constructQuery565 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24794  2 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery567 = new BitSet(new long[]{0x0000000000000002L});
 24795  2 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery592 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24796  2 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24797  2 
     public static final BitSet FOLLOW_WHERE_in_constructQuery597 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24798  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_constructQuery599 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24799  2 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery601 = new BitSet(new long[]{0x0000000000000002L});
 24800  2 
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery637 = new BitSet(new long[]{0x0000000000004000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24801  2 
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery643 = new BitSet(new long[]{0x0000000000000000L,0x1400010008010840L,0x0000000000000601L,0x0000000000002C00L});
 24802  2 
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery649 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24803  2 
     public static final BitSet FOLLOW_datasetClause_in_describeQuery652 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24804  2 
     public static final BitSet FOLLOW_whereClause_in_describeQuery655 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24805  2 
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery658 = new BitSet(new long[]{0x0000000000000002L});
 24806  2 
     public static final BitSet FOLLOW_ASK_in_askQuery697 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24807  2 
     public static final BitSet FOLLOW_datasetClause_in_askQuery699 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24808  2 
     public static final BitSet FOLLOW_whereClause_in_askQuery702 = new BitSet(new long[]{0x0000000000000002L});
 24809  2 
     public static final BitSet FOLLOW_FROM_in_datasetClause730 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24810  2 
     public static final BitSet FOLLOW_NAMED_in_datasetClause732 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24811  2 
     public static final BitSet FOLLOW_iriRef_in_datasetClause735 = new BitSet(new long[]{0x0000000000000002L});
 24812  2 
     public static final BitSet FOLLOW_WHERE_in_whereClause763 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24813  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause766 = new BitSet(new long[]{0x0000000000000002L});
 24814  2 
     public static final BitSet FOLLOW_groupClause_in_solutionModifier791 = new BitSet(new long[]{0x0000000000000002L,0x0400010000010000L,0x0000000000000001L});
 24815  2 
     public static final BitSet FOLLOW_havingClause_in_solutionModifier794 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L,0x0000000000000001L});
 24816  2 
     public static final BitSet FOLLOW_orderClause_in_solutionModifier797 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L});
 24817  2 
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier800 = new BitSet(new long[]{0x0000000000000002L});
 24818  2 
     public static final BitSet FOLLOW_GROUP_in_groupClause832 = new BitSet(new long[]{0x0000000002000000L});
 24819  2 
     public static final BitSet FOLLOW_BY_in_groupClause834 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24820  2 
     public static final BitSet FOLLOW_groupCondition_in_groupClause836 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24821  2 
     public static final BitSet FOLLOW_builtInCall_in_groupCondition870 = new BitSet(new long[]{0x0000000000000002L});
 24822  2 
     public static final BitSet FOLLOW_functionCall_in_groupCondition886 = new BitSet(new long[]{0x0000000000000002L});
 24823  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_groupCondition902 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24824  2 
     public static final BitSet FOLLOW_expression_in_groupCondition904 = new BitSet(new long[]{0x0000000010000800L});
 24825  2 
     public static final BitSet FOLLOW_AS_in_groupCondition907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24826  2 
     public static final BitSet FOLLOW_var_in_groupCondition909 = new BitSet(new long[]{0x0000000010000000L});
 24827  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_groupCondition913 = new BitSet(new long[]{0x0000000000000002L});
 24828  2 
     public static final BitSet FOLLOW_var_in_groupCondition937 = new BitSet(new long[]{0x0000000000000002L});
 24829  2 
     public static final BitSet FOLLOW_HAVING_in_havingClause966 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24830  2 
     public static final BitSet FOLLOW_constraint_in_havingClause968 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24831  2 
     public static final BitSet FOLLOW_ORDER_in_orderClause1000 = new BitSet(new long[]{0x0000000002000000L});
 24832  2 
     public static final BitSet FOLLOW_BY_in_orderClause1002 = new BitSet(new long[]{0x2004184884C01020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24833  2 
     public static final BitSet FOLLOW_orderCondition_in_orderClause1004 = new BitSet(new long[]{0x2004184884C01022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24834  2 
     public static final BitSet FOLLOW_ASC_in_orderCondition1031 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24835  2 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1033 = new BitSet(new long[]{0x0000000000000002L});
 24836  2 
     public static final BitSet FOLLOW_DESC_in_orderCondition1051 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24837  2 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1053 = new BitSet(new long[]{0x0000000000000002L});
 24838  2 
     public static final BitSet FOLLOW_constraint_in_orderCondition1071 = new BitSet(new long[]{0x0000000000000002L});
 24839  2 
     public static final BitSet FOLLOW_var_in_orderCondition1087 = new BitSet(new long[]{0x0000000000000002L});
 24840  2 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1117 = new BitSet(new long[]{0x0000000000000002L,0x0400000000000000L});
 24841  2 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1119 = new BitSet(new long[]{0x0000000000000002L});
 24842  2 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1135 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
 24843  2 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1137 = new BitSet(new long[]{0x0000000000000002L});
 24844  2 
     public static final BitSet FOLLOW_LIMIT_in_limitClause1162 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24845  2 
     public static final BitSet FOLLOW_INTEGER_in_limitClause1164 = new BitSet(new long[]{0x0000000000000002L});
 24846  2 
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1189 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24847  2 
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1191 = new BitSet(new long[]{0x0000000000000002L});
 24848  2 
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1217 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24849  2 
     public static final BitSet FOLLOW_var_in_bindingsClause1219 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24850  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1222 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24851  2 
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1224 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24852  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1227 = new BitSet(new long[]{0x0000000000000002L});
 24853  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_bindingValueList1263 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24854  2 
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1265 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24855  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bindingValueList1268 = new BitSet(new long[]{0x0000000000000002L});
 24856  2 
     public static final BitSet FOLLOW_iriRef_in_bindingValue1299 = new BitSet(new long[]{0x0000000000000002L});
 24857  2 
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1303 = new BitSet(new long[]{0x0000000000000002L});
 24858  2 
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1307 = new BitSet(new long[]{0x0000000000000002L});
 24859  2 
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1311 = new BitSet(new long[]{0x0000000000000002L});
 24860  2 
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1315 = new BitSet(new long[]{0x0000000000000002L});
 24861  2 
     public static final BitSet FOLLOW_prologue_in_update1336 = new BitSet(new long[]{0x0802028008000040L,0x0004020000100000L,0x0000000000000000L,0x0000000000008000L});
 24862  2 
     public static final BitSet FOLLOW_load_in_update1339 = new BitSet(new long[]{0x0000000000000002L});
 24863  2 
     public static final BitSet FOLLOW_clear_in_update1343 = new BitSet(new long[]{0x0000000000000002L});
 24864  2 
     public static final BitSet FOLLOW_drop_in_update1347 = new BitSet(new long[]{0x0000000000000002L});
 24865  2 
     public static final BitSet FOLLOW_add_in_update1351 = new BitSet(new long[]{0x0000000000000002L});
 24866  2 
     public static final BitSet FOLLOW_move_in_update1355 = new BitSet(new long[]{0x0000000000000002L});
 24867  2 
     public static final BitSet FOLLOW_copy_in_update1359 = new BitSet(new long[]{0x0000000000000002L});
 24868  2 
     public static final BitSet FOLLOW_create_in_update1363 = new BitSet(new long[]{0x0000000000000002L});
 24869  2 
     public static final BitSet FOLLOW_insert_in_update1367 = new BitSet(new long[]{0x0000000000000002L});
 24870  2 
     public static final BitSet FOLLOW_delete_in_update1371 = new BitSet(new long[]{0x0000000000000002L});
 24871  2 
     public static final BitSet FOLLOW_modify_in_update1375 = new BitSet(new long[]{0x0000000000000002L});
 24872  2 
     public static final BitSet FOLLOW_LOAD_in_load1438 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L});
 24873  2 
     public static final BitSet FOLLOW_SILENT_in_load1440 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24874  2 
     public static final BitSet FOLLOW_iriRef_in_load1443 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
 24875  2 
     public static final BitSet FOLLOW_INTO_in_load1446 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 24876  2 
     public static final BitSet FOLLOW_graphRef_in_load1448 = new BitSet(new long[]{0x0000000000000002L});
 24877  2 
     public static final BitSet FOLLOW_CLEAR_in_clear1485 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 24878  2 
     public static final BitSet FOLLOW_SILENT_in_clear1488 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 24879  2 
     public static final BitSet FOLLOW_graphRefAll_in_clear1491 = new BitSet(new long[]{0x0000000000000002L});
 24880  2 
     public static final BitSet FOLLOW_DROP_in_drop1523 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 24881  2 
     public static final BitSet FOLLOW_SILENT_in_drop1525 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 24882  2 
     public static final BitSet FOLLOW_graphRefAll_in_drop1528 = new BitSet(new long[]{0x0000000000000002L});
 24883  2 
     public static final BitSet FOLLOW_CREATE_in_create1557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x0000020000000000L});
 24884  2 
     public static final BitSet FOLLOW_SILENT_in_create1559 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 24885  2 
     public static final BitSet FOLLOW_graphRef_in_create1562 = new BitSet(new long[]{0x0000000000000002L});
 24886  2 
     public static final BitSet FOLLOW_ADD_in_add1594 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24887  2 
     public static final BitSet FOLLOW_SILENT_in_add1596 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24888  2 
     public static final BitSet FOLLOW_graphOrDefault_in_add1601 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24889  2 
     public static final BitSet FOLLOW_TO_in_add1603 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24890  2 
     public static final BitSet FOLLOW_graphOrDefault_in_add1607 = new BitSet(new long[]{0x0000000000000002L});
 24891  2 
     public static final BitSet FOLLOW_MOVE_in_move1643 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24892  2 
     public static final BitSet FOLLOW_SILENT_in_move1645 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24893  2 
     public static final BitSet FOLLOW_graphOrDefault_in_move1650 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24894  2 
     public static final BitSet FOLLOW_TO_in_move1652 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24895  2 
     public static final BitSet FOLLOW_graphOrDefault_in_move1656 = new BitSet(new long[]{0x0000000000000002L});
 24896  2 
     public static final BitSet FOLLOW_COPY_in_copy1692 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24897  2 
     public static final BitSet FOLLOW_SILENT_in_copy1694 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24898  2 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1699 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24899  2 
     public static final BitSet FOLLOW_TO_in_copy1701 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24900  2 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1705 = new BitSet(new long[]{0x0000000000000002L});
 24901  2 
     public static final BitSet FOLLOW_INSERT_in_insert1737 = new BitSet(new long[]{0x0000040000000000L});
 24902  2 
     public static final BitSet FOLLOW_DATA_in_insert1739 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24903  2 
     public static final BitSet FOLLOW_quadPattern_in_insert1741 = new BitSet(new long[]{0x0000000000000002L});
 24904  2 
     public static final BitSet FOLLOW_DELETE_in_delete1775 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24905  2 
     public static final BitSet FOLLOW_deleteData_in_delete1778 = new BitSet(new long[]{0x0000000000000002L});
 24906  2 
     public static final BitSet FOLLOW_deleteWhere_in_delete1782 = new BitSet(new long[]{0x0000000000000002L});
 24907  2 
     public static final BitSet FOLLOW_DATA_in_deleteData1800 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24908  2 
     public static final BitSet FOLLOW_quadPattern_in_deleteData1802 = new BitSet(new long[]{0x0000000000000002L});
 24909  2 
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1829 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24910  2 
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1831 = new BitSet(new long[]{0x0000000000000002L});
 24911  2 
     public static final BitSet FOLLOW_WITH_in_modify1863 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24912  2 
     public static final BitSet FOLLOW_iriRef_in_modify1865 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L});
 24913  2 
     public static final BitSet FOLLOW_deleteClause_in_modify1870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000002100L});
 24914  2 
     public static final BitSet FOLLOW_insertClause_in_modify1872 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24915  2 
     public static final BitSet FOLLOW_insertClause_in_modify1877 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24916  2 
     public static final BitSet FOLLOW_usingClause_in_modify1880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24917  2 
     public static final BitSet FOLLOW_WHERE_in_modify1883 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24918  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_modify1885 = new BitSet(new long[]{0x0000000000000002L});
 24919  2 
     public static final BitSet FOLLOW_DELETE_in_deleteClause1932 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24920  2 
     public static final BitSet FOLLOW_quadPattern_in_deleteClause1934 = new BitSet(new long[]{0x0000000000000002L});
 24921  2 
     public static final BitSet FOLLOW_INSERT_in_insertClause1963 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24922  2 
     public static final BitSet FOLLOW_quadPattern_in_insertClause1965 = new BitSet(new long[]{0x0000000000000002L});
 24923  2 
     public static final BitSet FOLLOW_USING_in_usingClause1988 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24924  2 
     public static final BitSet FOLLOW_NAMED_in_usingClause1990 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24925  2 
     public static final BitSet FOLLOW_iriRef_in_usingClause1993 = new BitSet(new long[]{0x0000000000000002L});
 24926  2 
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2024 = new BitSet(new long[]{0x0000000000000002L});
 24927  2 
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2033 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24928  2 
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2036 = new BitSet(new long[]{0x0000000000000002L});
 24929  2 
     public static final BitSet FOLLOW_GRAPH_in_graphRef2063 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24930  2 
     public static final BitSet FOLLOW_iriRef_in_graphRef2065 = new BitSet(new long[]{0x0000000000000002L});
 24931  2 
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2082 = new BitSet(new long[]{0x0000000000000002L});
 24932  2 
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2086 = new BitSet(new long[]{0x0000000000000002L});
 24933  2 
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2090 = new BitSet(new long[]{0x0000000000000002L});
 24934  2 
     public static final BitSet FOLLOW_ALL_in_graphRefAll2094 = new BitSet(new long[]{0x0000000000000002L});
 24935  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2111 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24936  2 
     public static final BitSet FOLLOW_quads_in_quadPattern2113 = new BitSet(new long[]{0x0000000020000000L});
 24937  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2115 = new BitSet(new long[]{0x0000000000000002L});
 24938  2 
     public static final BitSet FOLLOW_triplesTemplate_in_quads2140 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 24939  2 
     public static final BitSet FOLLOW_quadsNotTriples_in_quads2144 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24940  2 
     public static final BitSet FOLLOW_DOT_in_quads2146 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24941  2 
     public static final BitSet FOLLOW_triplesTemplate_in_quads2149 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 24942  2 
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2188 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24943  2 
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2190 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24944  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2192 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24945  2 
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2194 = new BitSet(new long[]{0x0000000020000000L});
 24946  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2197 = new BitSet(new long[]{0x0000000000000002L});
 24947  2 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2229 = new BitSet(new long[]{0x0080000000000002L});
 24948  2 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2232 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24949  2 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2234 = new BitSet(new long[]{0x0080000000000002L});
 24950  2 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2238 = new BitSet(new long[]{0x0000000000000002L});
 24951  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 24952  2 
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2272 = new BitSet(new long[]{0x0000000020000000L});
 24953  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2274 = new BitSet(new long[]{0x0000000000000002L});
 24954  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2290 = new BitSet(new long[]{0x0700E00000220000L,0x7800400008E00118L,0x0007800400000600L,0x0000000000000C01L});
 24955  2 
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2292 = new BitSet(new long[]{0x0000000020000000L});
 24956  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2294 = new BitSet(new long[]{0x0000000000000002L});
 24957  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2310 = new BitSet(new long[]{0x0000000020000000L});
 24958  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2312 = new BitSet(new long[]{0x0000000000000002L});
 24959  2 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2341 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24960  2 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2343 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24961  2 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2359 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24962  2 
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2382 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24963  2 
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2384 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24964  2 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2387 = new BitSet(new long[]{0x0000000000000002L});
 24965  2 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2412 = new BitSet(new long[]{0x0080000000000002L});
 24966  2 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2415 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24967  2 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2417 = new BitSet(new long[]{0x0080000000000002L});
 24968  2 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2421 = new BitSet(new long[]{0x0000000000000002L});
 24969  2 
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2444 = new BitSet(new long[]{0x0000000000000002L});
 24970  2 
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2448 = new BitSet(new long[]{0x0000000000000002L});
 24971  2 
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2452 = new BitSet(new long[]{0x0000000000000002L});
 24972  2 
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2456 = new BitSet(new long[]{0x0000000000000002L});
 24973  2 
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2460 = new BitSet(new long[]{0x0000000000000002L});
 24974  2 
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2464 = new BitSet(new long[]{0x0000000000000002L});
 24975  2 
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2468 = new BitSet(new long[]{0x0000000000000002L});
 24976  2 
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2485 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24977  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2487 = new BitSet(new long[]{0x0000000000000002L});
 24978  2 
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2512 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24979  2 
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2514 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24980  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2516 = new BitSet(new long[]{0x0000000000000002L});
 24981  2 
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2543 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L,0x0000000000000C00L});
 24982  2 
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2545 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24983  2 
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2548 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24984  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2550 = new BitSet(new long[]{0x0000000000000002L});
 24985  2 
     public static final BitSet FOLLOW_BIND_in_bind2584 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24986  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_bind2586 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24987  2 
     public static final BitSet FOLLOW_expression_in_bind2588 = new BitSet(new long[]{0x0000000000000800L});
 24988  2 
     public static final BitSet FOLLOW_AS_in_bind2590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24989  2 
     public static final BitSet FOLLOW_var_in_bind2592 = new BitSet(new long[]{0x0000000010000000L});
 24990  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bind2594 = new BitSet(new long[]{0x0000000000000002L});
 24991  2 
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2631 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24992  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2633 = new BitSet(new long[]{0x0000000000000002L});
 24993  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2661 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 24994  2 
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2669 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24995  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2673 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 24996  2 
     public static final BitSet FOLLOW_FILTER_in_filter2705 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24997  2 
     public static final BitSet FOLLOW_constraint_in_filter2707 = new BitSet(new long[]{0x0000000000000002L});
 24998  2 
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2732 = new BitSet(new long[]{0x0000000000000002L});
 24999  2 
     public static final BitSet FOLLOW_builtInCall_in_constraint2740 = new BitSet(new long[]{0x0000000000000002L});
 25000  2 
     public static final BitSet FOLLOW_functionCall_in_constraint2748 = new BitSet(new long[]{0x0000000000000002L});
 25001  2 
     public static final BitSet FOLLOW_iriRef_in_functionCall2765 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25002  2 
     public static final BitSet FOLLOW_argList_in_functionCall2767 = new BitSet(new long[]{0x0000000000000002L});
 25003  2 
     public static final BitSet FOLLOW_nil_in_argList2798 = new BitSet(new long[]{0x0000000000000002L});
 25004  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_argList2810 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25005  2 
     public static final BitSet FOLLOW_DISTINCT_in_argList2812 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25006  2 
     public static final BitSet FOLLOW_expression_in_argList2815 = new BitSet(new long[]{0x0000000210000000L});
 25007  2 
     public static final BitSet FOLLOW_COMMA_in_argList2818 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25008  2 
     public static final BitSet FOLLOW_expression_in_argList2820 = new BitSet(new long[]{0x0000000210000000L});
 25009  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_argList2824 = new BitSet(new long[]{0x0000000000000002L});
 25010  2 
     public static final BitSet FOLLOW_nil_in_expressionList2850 = new BitSet(new long[]{0x0000000000000002L});
 25011  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_expressionList2854 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25012  2 
     public static final BitSet FOLLOW_expression_in_expressionList2856 = new BitSet(new long[]{0x0000000210000000L});
 25013  2 
     public static final BitSet FOLLOW_COMMA_in_expressionList2859 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25014  2 
     public static final BitSet FOLLOW_expression_in_expressionList2861 = new BitSet(new long[]{0x0000000210000000L});
 25015  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_expressionList2865 = new BitSet(new long[]{0x0000000000000002L});
 25016  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2896 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25017  2 
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate2898 = new BitSet(new long[]{0x0000000020000000L});
 25018  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2901 = new BitSet(new long[]{0x0000000000000002L});
 25019  2 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2927 = new BitSet(new long[]{0x0080000000000002L});
 25020  2 
     public static final BitSet FOLLOW_DOT_in_constructTriples2930 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25021  2 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2932 = new BitSet(new long[]{0x0080000000000002L});
 25022  2 
     public static final BitSet FOLLOW_DOT_in_constructTriples2936 = new BitSet(new long[]{0x0000000000000002L});
 25023  2 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject2959 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25024  2 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2961 = new BitSet(new long[]{0x0000000000000002L});
 25025  2 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject2985 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25026  2 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2987 = new BitSet(new long[]{0x0000000000000002L});
 25027  2 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3017 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25028  2 
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmpty3020 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25029  2 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3022 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25030  2 
     public static final BitSet FOLLOW_graphNode_in_objectList3048 = new BitSet(new long[]{0x0000000200000002L});
 25031  2 
     public static final BitSet FOLLOW_COMMA_in_objectList3051 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25032  2 
     public static final BitSet FOLLOW_graphNode_in_objectList3053 = new BitSet(new long[]{0x0000000200000002L});
 25033  2 
     public static final BitSet FOLLOW_varOrIRIref_in_verb3081 = new BitSet(new long[]{0x0000000000000002L});
 25034  2 
     public static final BitSet FOLLOW_A_in_verb3089 = new BitSet(new long[]{0x0000000000000002L});
 25035  2 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3106 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25036  2 
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3108 = new BitSet(new long[]{0x0000000000000002L});
 25037  2 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3130 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25038  2 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3132 = new BitSet(new long[]{0x0000000000000002L});
 25039  2 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3164 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25040  2 
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3167 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25041  2 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3169 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25042  2 
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3196 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25043  2 
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3198 = new BitSet(new long[]{0x0000000000000002L});
 25044  2 
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3228 = new BitSet(new long[]{0x0000000000000002L});
 25045  2 
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3236 = new BitSet(new long[]{0x0000000000000002L});
 25046  2 
     public static final BitSet FOLLOW_path_in_verbPath3255 = new BitSet(new long[]{0x0000000000000002L});
 25047  2 
     public static final BitSet FOLLOW_var_in_verbSimple3276 = new BitSet(new long[]{0x0000000000000002L});
 25048  2 
     public static final BitSet FOLLOW_pathSequence_in_path3298 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25049  2 
     public static final BitSet FOLLOW_PIPE_in_path3301 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25050  2 
     public static final BitSet FOLLOW_pathSequence_in_path3303 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25051  2 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3332 = new BitSet(new long[]{0x0040000000000002L});
 25052  2 
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3335 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25053  2 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3337 = new BitSet(new long[]{0x0040000000000002L});
 25054  2 
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3365 = new BitSet(new long[]{0x0000000000000010L,0x0810000008000000L,0x0000000000000600L});
 25055  2 
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3368 = new BitSet(new long[]{0x0000000000000002L});
 25056  2 
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3396 = new BitSet(new long[]{0x0000000000004002L,0x1000000000000000L,0x0000000000100100L});
 25057  2 
     public static final BitSet FOLLOW_pathMod_in_pathElt3398 = new BitSet(new long[]{0x0000000000000002L});
 25058  2 
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3417 = new BitSet(new long[]{0x0000000000000002L});
 25059  2 
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3421 = new BitSet(new long[]{0x0000000000000002L});
 25060  2 
     public static final BitSet FOLLOW_PLUS_in_pathMod3425 = new BitSet(new long[]{0x0000000000000002L});
 25061  2 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_pathMod3429 = new BitSet(new long[]{0x0000000200000000L,0x0000000000200000L});
 25062  2 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3432 = new BitSet(new long[]{0x0000000220000000L});
 25063  2 
     public static final BitSet FOLLOW_COMMA_in_pathMod3435 = new BitSet(new long[]{0x0000000020000000L,0x0000000000200000L});
 25064  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3438 = new BitSet(new long[]{0x0000000000000002L});
 25065  2 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3442 = new BitSet(new long[]{0x0000000020000000L});
 25066  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3444 = new BitSet(new long[]{0x0000000000000002L});
 25067  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3449 = new BitSet(new long[]{0x0000000000000002L});
 25068  2 
     public static final BitSet FOLLOW_COMMA_in_pathMod3454 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 25069  2 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3456 = new BitSet(new long[]{0x0000000020000000L});
 25070  2 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3458 = new BitSet(new long[]{0x0000000000000002L});
 25071  2 
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3477 = new BitSet(new long[]{0x0000000000000002L});
 25072  2 
     public static final BitSet FOLLOW_A_in_pathPrimary3493 = new BitSet(new long[]{0x0000000000000002L});
 25073  2 
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3509 = new BitSet(new long[]{0x0000000000000010L,0x080000000A000000L,0x0000000000000600L});
 25074  2 
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3511 = new BitSet(new long[]{0x0000000000000002L});
 25075  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathPrimary3529 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25076  2 
     public static final BitSet FOLLOW_path_in_pathPrimary3531 = new BitSet(new long[]{0x0000000010000000L});
 25077  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathPrimary3533 = new BitSet(new long[]{0x0000000000000002L});
 25078  2 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3558 = new BitSet(new long[]{0x0000000000000002L});
 25079  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3574 = new BitSet(new long[]{0x0000000010000010L,0x000000000A000000L,0x0000000000000600L});
 25080  2 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3577 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25081  2 
     public static final BitSet FOLLOW_PIPE_in_pathNegatedPropertySet3580 = new BitSet(new long[]{0x0000000000000010L,0x000000000A000000L,0x0000000000000600L});
 25082  2 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3582 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25083  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3588 = new BitSet(new long[]{0x0000000000000002L});
 25084  2 
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3617 = new BitSet(new long[]{0x0000000000000010L,0x0000000008000000L,0x0000000000000600L});
 25085  2 
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3621 = new BitSet(new long[]{0x0000000000000002L});
 25086  2 
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3625 = new BitSet(new long[]{0x0000000000000002L});
 25087  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_triplesNode3644 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25088  2 
     public static final BitSet FOLLOW_graphNode_in_triplesNode3646 = new BitSet(new long[]{0x0700E00010200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25089  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_triplesNode3649 = new BitSet(new long[]{0x0000000000000002L});
 25090  2 
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3666 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25091  2 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3668 = new BitSet(new long[]{0x0000000040000000L});
 25092  2 
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3670 = new BitSet(new long[]{0x0000000000000002L});
 25093  2 
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3695 = new BitSet(new long[]{0x0000000000000002L});
 25094  2 
     public static final BitSet FOLLOW_triplesNode_in_graphNode3699 = new BitSet(new long[]{0x0000000000000002L});
 25095  2 
     public static final BitSet FOLLOW_var_in_varOrTerm3716 = new BitSet(new long[]{0x0000000000000002L});
 25096  2 
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3724 = new BitSet(new long[]{0x0000000000000002L});
 25097  2 
     public static final BitSet FOLLOW_var_in_varOrIRIref3741 = new BitSet(new long[]{0x0000000000000002L});
 25098  2 
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref3745 = new BitSet(new long[]{0x0000000000000002L});
 25099  2 
     public static final BitSet FOLLOW_iriRef_in_graphTerm3783 = new BitSet(new long[]{0x0000000000000002L});
 25100  2 
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm3791 = new BitSet(new long[]{0x0000000000000002L});
 25101  2 
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm3799 = new BitSet(new long[]{0x0000000000000002L});
 25102  2 
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm3807 = new BitSet(new long[]{0x0000000000000002L});
 25103  2 
     public static final BitSet FOLLOW_blankNode_in_graphTerm3815 = new BitSet(new long[]{0x0000000000000002L});
 25104  2 
     public static final BitSet FOLLOW_nil_in_graphTerm3823 = new BitSet(new long[]{0x0000000000000002L});
 25105  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_nil3844 = new BitSet(new long[]{0x0000000010000000L});
 25106  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_nil3846 = new BitSet(new long[]{0x0000000000000002L});
 25107  2 
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression3863 = new BitSet(new long[]{0x0000000000000002L});
 25108  2 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3883 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25109  2 
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression3892 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25110  2 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3896 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25111  2 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3930 = new BitSet(new long[]{0x0000000000000102L});
 25112  2 
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression3939 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25113  2 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3943 = new BitSet(new long[]{0x0000000000000102L});
 25114  2 
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical3974 = new BitSet(new long[]{0x0000000000000002L});
 25115  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression3994 = new BitSet(new long[]{0x8000000000000002L,0x006000C000080600L});
 25116  2 
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4004 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25117  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4008 = new BitSet(new long[]{0x0000000000000002L});
 25118  2 
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4065 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25119  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4069 = new BitSet(new long[]{0x0000000000000002L});
 25120  2 
     public static final BitSet FOLLOW_LESS_in_relationalExpression4124 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25121  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4128 = new BitSet(new long[]{0x0000000000000002L});
 25122  2 
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4183 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25123  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4187 = new BitSet(new long[]{0x0000000000000002L});
 25124  2 
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4241 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25125  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4245 = new BitSet(new long[]{0x0000000000000002L});
 25126  2 
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4299 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25127  2 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4303 = new BitSet(new long[]{0x0000000000000002L});
 25128  2 
     public static final BitSet FOLLOW_IN_in_relationalExpression4359 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25129  2 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4363 = new BitSet(new long[]{0x0000000000000002L});
 25130  2 
     public static final BitSet FOLLOW_NOT_in_relationalExpression4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25131  2 
     public static final BitSet FOLLOW_IN_in_relationalExpression4419 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25132  2 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4423 = new BitSet(new long[]{0x0000000000000002L});
 25133  2 
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4457 = new BitSet(new long[]{0x0000000000000002L});
 25134  2 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4477 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25135  2 
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4487 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25136  2 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4491 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25137  2 
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4558 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25138  2 
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4576 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25139  2 
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4640 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25140  2 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4644 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25141  2 
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4710 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25142  2 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4714 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25143  2 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4780 = new BitSet(new long[]{0x0040000000004002L});
 25144  2 
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression4789 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25145  2 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4793 = new BitSet(new long[]{0x0040000000004002L});
 25146  2 
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression4849 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25147  2 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4851 = new BitSet(new long[]{0x0000000000000002L});
 25148  2 
     public static final BitSet FOLLOW_PLUS_in_unaryExpression4869 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25149  2 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4871 = new BitSet(new long[]{0x0000000000000002L});
 25150  2 
     public static final BitSet FOLLOW_MINUS_in_unaryExpression4889 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25151  2 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4891 = new BitSet(new long[]{0x0000000000000002L});
 25152  2 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4909 = new BitSet(new long[]{0x0000000000000002L});
 25153  2 
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression4934 = new BitSet(new long[]{0x0000000000000002L});
 25154  2 
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression4938 = new BitSet(new long[]{0x0000000000000002L});
 25155  2 
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression4942 = new BitSet(new long[]{0x0000000000000002L});
 25156  2 
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression4946 = new BitSet(new long[]{0x0000000000000002L});
 25157  2 
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression4950 = new BitSet(new long[]{0x0000000000000002L});
 25158  2 
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression4954 = new BitSet(new long[]{0x0000000000000002L});
 25159  2 
     public static final BitSet FOLLOW_var_in_primaryExpression4958 = new BitSet(new long[]{0x0000000000000002L});
 25160  2 
     public static final BitSet FOLLOW_aggregate_in_primaryExpression4962 = new BitSet(new long[]{0x0000000000000002L});
 25161  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_brackettedExpression4979 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25162  2 
     public static final BitSet FOLLOW_expression_in_brackettedExpression4981 = new BitSet(new long[]{0x0000000010000000L});
 25163  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_brackettedExpression4983 = new BitSet(new long[]{0x0000000000000002L});
 25164  2 
     public static final BitSet FOLLOW_STR_in_builtInCall5008 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25165  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5010 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25166  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5012 = new BitSet(new long[]{0x0000000010000000L});
 25167  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5014 = new BitSet(new long[]{0x0000000000000002L});
 25168  2 
     public static final BitSet FOLLOW_LANG_in_builtInCall5030 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25169  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5032 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25170  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5034 = new BitSet(new long[]{0x0000000010000000L});
 25171  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5036 = new BitSet(new long[]{0x0000000000000002L});
 25172  2 
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5052 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25173  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5054 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25174  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5056 = new BitSet(new long[]{0x0000000200000000L});
 25175  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5058 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25176  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5060 = new BitSet(new long[]{0x0000000010000000L});
 25177  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5062 = new BitSet(new long[]{0x0000000000000002L});
 25178  2 
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5079 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25179  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5081 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25180  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5083 = new BitSet(new long[]{0x0000000010000000L});
 25181  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5085 = new BitSet(new long[]{0x0000000000000002L});
 25182  2 
     public static final BitSet FOLLOW_BOUND_in_builtInCall5101 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25183  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5103 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25184  2 
     public static final BitSet FOLLOW_var_in_builtInCall5105 = new BitSet(new long[]{0x0000000010000000L});
 25185  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5107 = new BitSet(new long[]{0x0000000000000002L});
 25186  2 
     public static final BitSet FOLLOW_IRI_in_builtInCall5123 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25187  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5125 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25188  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5127 = new BitSet(new long[]{0x0000000010000000L});
 25189  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5129 = new BitSet(new long[]{0x0000000000000002L});
 25190  2 
     public static final BitSet FOLLOW_URI_in_builtInCall5145 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25191  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5147 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25192  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5149 = new BitSet(new long[]{0x0000000010000000L});
 25193  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5151 = new BitSet(new long[]{0x0000000000000002L});
 25194  2 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5167 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25195  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5170 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25196  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5172 = new BitSet(new long[]{0x0000000010000000L});
 25197  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5174 = new BitSet(new long[]{0x0000000000000002L});
 25198  2 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5191 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25199  2 
     public static final BitSet FOLLOW_nil_in_builtInCall5193 = new BitSet(new long[]{0x0000000000000002L});
 25200  2 
     public static final BitSet FOLLOW_RAND_in_builtInCall5205 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25201  2 
     public static final BitSet FOLLOW_nil_in_builtInCall5207 = new BitSet(new long[]{0x0000000000000002L});
 25202  2 
     public static final BitSet FOLLOW_ABS_in_builtInCall5219 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25203  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5221 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25204  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5223 = new BitSet(new long[]{0x0000000010000000L});
 25205  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5225 = new BitSet(new long[]{0x0000000000000002L});
 25206  2 
     public static final BitSet FOLLOW_CEIL_in_builtInCall5241 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25207  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5243 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25208  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5245 = new BitSet(new long[]{0x0000000010000000L});
 25209  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5247 = new BitSet(new long[]{0x0000000000000002L});
 25210  2 
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5263 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25211  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5265 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25212  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5267 = new BitSet(new long[]{0x0000000010000000L});
 25213  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5269 = new BitSet(new long[]{0x0000000000000002L});
 25214  2 
     public static final BitSet FOLLOW_ROUND_in_builtInCall5285 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25215  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5287 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25216  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5289 = new BitSet(new long[]{0x0000000010000000L});
 25217  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5291 = new BitSet(new long[]{0x0000000000000002L});
 25218  2 
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5307 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25219  2 
     public static final BitSet FOLLOW_expressionList_in_builtInCall5309 = new BitSet(new long[]{0x0000000000000002L});
 25220  2 
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5325 = new BitSet(new long[]{0x0000000000000002L});
 25221  2 
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5337 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25222  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5339 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25223  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5341 = new BitSet(new long[]{0x0000000010000000L});
 25224  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5343 = new BitSet(new long[]{0x0000000000000002L});
 25225  2 
     public static final BitSet FOLLOW_UCASE_in_builtInCall5359 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25226  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5361 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25227  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5363 = new BitSet(new long[]{0x0000000010000000L});
 25228  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5365 = new BitSet(new long[]{0x0000000000000002L});
 25229  2 
     public static final BitSet FOLLOW_LCASE_in_builtInCall5381 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25230  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5383 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25231  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5385 = new BitSet(new long[]{0x0000000010000000L});
 25232  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5387 = new BitSet(new long[]{0x0000000000000002L});
 25233  2 
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5403 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25234  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5405 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25235  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5407 = new BitSet(new long[]{0x0000000010000000L});
 25236  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5409 = new BitSet(new long[]{0x0000000000000002L});
 25237  2 
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5425 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25238  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5427 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25239  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5429 = new BitSet(new long[]{0x0000000200000000L});
 25240  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5431 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25241  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5433 = new BitSet(new long[]{0x0000000010000000L});
 25242  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5435 = new BitSet(new long[]{0x0000000000000002L});
 25243  2 
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5453 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25244  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5455 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25245  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5457 = new BitSet(new long[]{0x0000000200000000L});
 25246  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5459 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25247  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5461 = new BitSet(new long[]{0x0000000010000000L});
 25248  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5463 = new BitSet(new long[]{0x0000000000000002L});
 25249  2 
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5481 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25250  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5483 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25251  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5485 = new BitSet(new long[]{0x0000000200000000L});
 25252  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5487 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25253  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5489 = new BitSet(new long[]{0x0000000010000000L});
 25254  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5491 = new BitSet(new long[]{0x0000000000000002L});
 25255  2 
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5509 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25256  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5511 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25257  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5513 = new BitSet(new long[]{0x0000000200000000L});
 25258  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5515 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25259  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5517 = new BitSet(new long[]{0x0000000010000000L});
 25260  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5519 = new BitSet(new long[]{0x0000000000000002L});
 25261  2 
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5537 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25262  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5539 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25263  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5541 = new BitSet(new long[]{0x0000000200000000L});
 25264  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5543 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25265  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5545 = new BitSet(new long[]{0x0000000010000000L});
 25266  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5547 = new BitSet(new long[]{0x0000000000000002L});
 25267  2 
     public static final BitSet FOLLOW_REPLACE_in_builtInCall5565 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25268  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5567 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25269  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5569 = new BitSet(new long[]{0x0000000200000000L});
 25270  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5571 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25271  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5573 = new BitSet(new long[]{0x0000000200000000L});
 25272  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5575 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25273  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5577 = new BitSet(new long[]{0x0000000010000000L});
 25274  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5579 = new BitSet(new long[]{0x0000000000000002L});
 25275  2 
     public static final BitSet FOLLOW_YEAR_in_builtInCall5599 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25276  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5601 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25277  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5603 = new BitSet(new long[]{0x0000000010000000L});
 25278  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5605 = new BitSet(new long[]{0x0000000000000002L});
 25279  2 
     public static final BitSet FOLLOW_MONTH_in_builtInCall5621 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25280  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5623 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25281  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5625 = new BitSet(new long[]{0x0000000010000000L});
 25282  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5627 = new BitSet(new long[]{0x0000000000000002L});
 25283  2 
     public static final BitSet FOLLOW_DAY_in_builtInCall5643 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25284  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5645 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25285  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5647 = new BitSet(new long[]{0x0000000010000000L});
 25286  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5649 = new BitSet(new long[]{0x0000000000000002L});
 25287  2 
     public static final BitSet FOLLOW_HOURS_in_builtInCall5665 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25288  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5667 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25289  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5669 = new BitSet(new long[]{0x0000000010000000L});
 25290  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5671 = new BitSet(new long[]{0x0000000000000002L});
 25291  2 
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5687 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25292  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5689 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25293  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5691 = new BitSet(new long[]{0x0000000010000000L});
 25294  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5693 = new BitSet(new long[]{0x0000000000000002L});
 25295  2 
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5709 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25296  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5711 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25297  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5713 = new BitSet(new long[]{0x0000000010000000L});
 25298  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5715 = new BitSet(new long[]{0x0000000000000002L});
 25299  2 
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5731 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25300  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5733 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25301  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5735 = new BitSet(new long[]{0x0000000010000000L});
 25302  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5737 = new BitSet(new long[]{0x0000000000000002L});
 25303  2 
     public static final BitSet FOLLOW_TZ_in_builtInCall5753 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25304  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5755 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25305  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5757 = new BitSet(new long[]{0x0000000010000000L});
 25306  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5759 = new BitSet(new long[]{0x0000000000000002L});
 25307  2 
     public static final BitSet FOLLOW_NOW_in_builtInCall5775 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25308  2 
     public static final BitSet FOLLOW_nil_in_builtInCall5777 = new BitSet(new long[]{0x0000000000000002L});
 25309  2 
     public static final BitSet FOLLOW_MD5_in_builtInCall5789 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25310  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5791 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25311  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5793 = new BitSet(new long[]{0x0000000010000000L});
 25312  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5795 = new BitSet(new long[]{0x0000000000000002L});
 25313  2 
     public static final BitSet FOLLOW_SHA1_in_builtInCall5811 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25314  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5813 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25315  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5815 = new BitSet(new long[]{0x0000000010000000L});
 25316  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5817 = new BitSet(new long[]{0x0000000000000002L});
 25317  2 
     public static final BitSet FOLLOW_SHA224_in_builtInCall5833 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25318  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5835 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25319  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5837 = new BitSet(new long[]{0x0000000010000000L});
 25320  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5839 = new BitSet(new long[]{0x0000000000000002L});
 25321  2 
     public static final BitSet FOLLOW_SHA256_in_builtInCall5855 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25322  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5857 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25323  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5859 = new BitSet(new long[]{0x0000000010000000L});
 25324  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5861 = new BitSet(new long[]{0x0000000000000002L});
 25325  2 
     public static final BitSet FOLLOW_SHA384_in_builtInCall5877 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25326  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5879 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25327  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5881 = new BitSet(new long[]{0x0000000010000000L});
 25328  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5883 = new BitSet(new long[]{0x0000000000000002L});
 25329  2 
     public static final BitSet FOLLOW_SHA512_in_builtInCall5899 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25330  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5901 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25331  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5903 = new BitSet(new long[]{0x0000000010000000L});
 25332  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5905 = new BitSet(new long[]{0x0000000000000002L});
 25333  2 
     public static final BitSet FOLLOW_COALESCE_in_builtInCall5921 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25334  2 
     public static final BitSet FOLLOW_expressionList_in_builtInCall5923 = new BitSet(new long[]{0x0000000000000002L});
 25335  2 
     public static final BitSet FOLLOW_IF_in_builtInCall5939 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25336  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5941 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25337  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5945 = new BitSet(new long[]{0x0000000200000000L});
 25338  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5947 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25339  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5951 = new BitSet(new long[]{0x0000000200000000L});
 25340  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5953 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25341  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5957 = new BitSet(new long[]{0x0000000010000000L});
 25342  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5959 = new BitSet(new long[]{0x0000000000000002L});
 25343  2 
     public static final BitSet FOLLOW_STRLANG_in_builtInCall5982 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25344  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5984 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25345  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5986 = new BitSet(new long[]{0x0000000200000000L});
 25346  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5988 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25347  2 
     public static final BitSet FOLLOW_expression_in_builtInCall5990 = new BitSet(new long[]{0x0000000010000000L});
 25348  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5992 = new BitSet(new long[]{0x0000000000000002L});
 25349  2 
     public static final BitSet FOLLOW_STRDT_in_builtInCall6010 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25350  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6012 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25351  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6014 = new BitSet(new long[]{0x0000000200000000L});
 25352  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall6016 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25353  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6018 = new BitSet(new long[]{0x0000000010000000L});
 25354  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6020 = new BitSet(new long[]{0x0000000000000002L});
 25355  2 
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6038 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25356  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6040 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25357  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6042 = new BitSet(new long[]{0x0000000200000000L});
 25358  2 
     public static final BitSet FOLLOW_COMMA_in_builtInCall6044 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25359  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6046 = new BitSet(new long[]{0x0000000010000000L});
 25360  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6048 = new BitSet(new long[]{0x0000000000000002L});
 25361  2 
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6066 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25362  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6068 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25363  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6070 = new BitSet(new long[]{0x0000000010000000L});
 25364  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6072 = new BitSet(new long[]{0x0000000000000002L});
 25365  2 
     public static final BitSet FOLLOW_ISURI_in_builtInCall6088 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25366  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6090 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25367  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6092 = new BitSet(new long[]{0x0000000010000000L});
 25368  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6094 = new BitSet(new long[]{0x0000000000000002L});
 25369  2 
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6110 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25370  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6112 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25371  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6114 = new BitSet(new long[]{0x0000000010000000L});
 25372  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6116 = new BitSet(new long[]{0x0000000000000002L});
 25373  2 
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6133 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25374  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6135 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25375  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6137 = new BitSet(new long[]{0x0000000010000000L});
 25376  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6139 = new BitSet(new long[]{0x0000000000000002L});
 25377  2 
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6155 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25378  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6157 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25379  2 
     public static final BitSet FOLLOW_expression_in_builtInCall6159 = new BitSet(new long[]{0x0000000010000000L});
 25380  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6161 = new BitSet(new long[]{0x0000000000000002L});
 25381  2 
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6177 = new BitSet(new long[]{0x0000000000000002L});
 25382  2 
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6189 = new BitSet(new long[]{0x0000000000000002L});
 25383  2 
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6201 = new BitSet(new long[]{0x0000000000000002L});
 25384  2 
     public static final BitSet FOLLOW_REGEX_in_regexExpression6222 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25385  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_regexExpression6224 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25386  2 
     public static final BitSet FOLLOW_expression_in_regexExpression6226 = new BitSet(new long[]{0x0000000200000000L});
 25387  2 
     public static final BitSet FOLLOW_COMMA_in_regexExpression6228 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25388  2 
     public static final BitSet FOLLOW_expression_in_regexExpression6230 = new BitSet(new long[]{0x0000000210000000L});
 25389  2 
     public static final BitSet FOLLOW_COMMA_in_regexExpression6233 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25390  2 
     public static final BitSet FOLLOW_expression_in_regexExpression6235 = new BitSet(new long[]{0x0000000010000000L});
 25391  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_regexExpression6239 = new BitSet(new long[]{0x0000000000000002L});
 25392  2 
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6269 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25393  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_subStringExpression6271 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25394  2 
     public static final BitSet FOLLOW_expression_in_subStringExpression6273 = new BitSet(new long[]{0x0000000200000000L});
 25395  2 
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6275 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25396  2 
     public static final BitSet FOLLOW_expression_in_subStringExpression6277 = new BitSet(new long[]{0x0000000210000000L});
 25397  2 
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6280 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25398  2 
     public static final BitSet FOLLOW_expression_in_subStringExpression6282 = new BitSet(new long[]{0x0000000010000000L});
 25399  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_subStringExpression6286 = new BitSet(new long[]{0x0000000000000002L});
 25400  2 
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6316 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25401  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6318 = new BitSet(new long[]{0x0000000000000002L});
 25402  2 
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6343 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
 25403  2 
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25404  2 
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6347 = new BitSet(new long[]{0x0000000000000002L});
 25405  2 
     public static final BitSet FOLLOW_COUNT_in_aggregate6372 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25406  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6374 = new BitSet(new long[]{0x2720F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25407  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6376 = new BitSet(new long[]{0x2700F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25408  2 
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6380 = new BitSet(new long[]{0x0000000010000000L});
 25409  2 
     public static final BitSet FOLLOW_expression_in_aggregate6384 = new BitSet(new long[]{0x0000000010000000L});
 25410  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6387 = new BitSet(new long[]{0x0000000000000002L});
 25411  2 
     public static final BitSet FOLLOW_SUM_in_aggregate6410 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25412  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6412 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25413  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6414 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25414  2 
     public static final BitSet FOLLOW_expression_in_aggregate6417 = new BitSet(new long[]{0x0000000010000000L});
 25415  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6419 = new BitSet(new long[]{0x0000000000000002L});
 25416  2 
     public static final BitSet FOLLOW_MIN_in_aggregate6438 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25417  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6440 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25418  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6442 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25419  2 
     public static final BitSet FOLLOW_expression_in_aggregate6445 = new BitSet(new long[]{0x0000000010000000L});
 25420  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6447 = new BitSet(new long[]{0x0000000000000002L});
 25421  2 
     public static final BitSet FOLLOW_MAX_in_aggregate6466 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25422  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6468 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25423  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6470 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25424  2 
     public static final BitSet FOLLOW_expression_in_aggregate6473 = new BitSet(new long[]{0x0000000010000000L});
 25425  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6475 = new BitSet(new long[]{0x0000000000000002L});
 25426  2 
     public static final BitSet FOLLOW_AVG_in_aggregate6494 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25427  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6496 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25428  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6498 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25429  2 
     public static final BitSet FOLLOW_expression_in_aggregate6501 = new BitSet(new long[]{0x0000000010000000L});
 25430  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6503 = new BitSet(new long[]{0x0000000000000002L});
 25431  2 
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6522 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25432  2 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6524 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25433  2 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6526 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25434  2 
     public static final BitSet FOLLOW_expression_in_aggregate6529 = new BitSet(new long[]{0x0000000010000000L});
 25435  2 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6531 = new BitSet(new long[]{0x0000000000000002L});
 25436  2 
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6550 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25437  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6552 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25438  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6554 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25439  1 
     public static final BitSet FOLLOW_expression_in_aggregate6557 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000100000000L});
 25440  1 
     public static final BitSet FOLLOW_SEMICOLON_in_aggregate6560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000200000000L});
 25441  1 
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6562 = new BitSet(new long[]{0x8000000000000000L});
 25442  1 
     public static final BitSet FOLLOW_EQUAL_in_aggregate6564 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0007800000000000L});
 25443  1 
     public static final BitSet FOLLOW_string_in_aggregate6566 = new BitSet(new long[]{0x0000000010000000L});
 25444  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6570 = new BitSet(new long[]{0x0000000000000002L});
 25445  1 
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6605 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25446  1 
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6607 = new BitSet(new long[]{0x0000000000000002L});
 25447  1 
     public static final BitSet FOLLOW_string_in_rdfLiteral6640 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L,0x0000000000800000L});
 25448  1 
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6643 = new BitSet(new long[]{0x0000000000000002L});
 25449  1 
     public static final BitSet FOLLOW_REFERENCE_in_rdfLiteral6648 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25450  1 
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6650 = new BitSet(new long[]{0x0000000000000002L});
 25451  1 
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6670 = new BitSet(new long[]{0x0000000000000002L});
 25452  1 
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6678 = new BitSet(new long[]{0x0000000000000002L});
 25453  1 
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6686 = new BitSet(new long[]{0x0000000000000002L});
 25454  1 
     public static final BitSet FOLLOW_IRI_REF_in_iriRef6869 = new BitSet(new long[]{0x0000000000000002L});
 25455  1 
     public static final BitSet FOLLOW_prefixedName_in_iriRef6877 = new BitSet(new long[]{0x0000000000000002L});
 25456  1 
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode6919 = new BitSet(new long[]{0x0000000000000002L});
 25457  1 
     public static final BitSet FOLLOW_anon_in_blankNode6927 = new BitSet(new long[]{0x0000000000000002L});
 25458  1 
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_anon6944 = new BitSet(new long[]{0x0000000040000000L});
 25459  1 
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6946 = new BitSet(new long[]{0x0000000000000002L});
 25460   
 
 25461   
 }
Report generated by Cobertura 1.9.4.1 on 07.12.11 00:14.